'Weak Dependency Graph [60.0]' ------------------------------ Answer: YES(?,O(n^1)) Input Problem: innermost runtime-complexity with respect to Rules: { active(zeros()) -> mark(cons(0(), zeros())) , active(and(tt(), X)) -> mark(X) , active(length(nil())) -> mark(0()) , active(length(cons(N, L))) -> mark(s(length(L))) , active(cons(X1, X2)) -> cons(active(X1), X2) , active(and(X1, X2)) -> and(active(X1), X2) , active(length(X)) -> length(active(X)) , active(s(X)) -> s(active(X)) , cons(mark(X1), X2) -> mark(cons(X1, X2)) , and(mark(X1), X2) -> mark(and(X1, X2)) , length(mark(X)) -> mark(length(X)) , s(mark(X)) -> mark(s(X)) , proper(zeros()) -> ok(zeros()) , proper(cons(X1, X2)) -> cons(proper(X1), proper(X2)) , proper(0()) -> ok(0()) , proper(and(X1, X2)) -> and(proper(X1), proper(X2)) , proper(tt()) -> ok(tt()) , proper(length(X)) -> length(proper(X)) , proper(nil()) -> ok(nil()) , proper(s(X)) -> s(proper(X)) , cons(ok(X1), ok(X2)) -> ok(cons(X1, X2)) , and(ok(X1), ok(X2)) -> ok(and(X1, X2)) , length(ok(X)) -> ok(length(X)) , s(ok(X)) -> ok(s(X)) , top(mark(X)) -> top(proper(X)) , top(ok(X)) -> top(active(X))} Details: We have computed the following set of weak (innermost) dependency pairs: { active^#(zeros()) -> c_0(cons^#(0(), zeros())) , active^#(and(tt(), X)) -> c_1() , active^#(length(nil())) -> c_2() , active^#(length(cons(N, L))) -> c_3(s^#(length(L))) , active^#(cons(X1, X2)) -> c_4(cons^#(active(X1), X2)) , active^#(and(X1, X2)) -> c_5(and^#(active(X1), X2)) , active^#(length(X)) -> c_6(length^#(active(X))) , active^#(s(X)) -> c_7(s^#(active(X))) , cons^#(mark(X1), X2) -> c_8(cons^#(X1, X2)) , and^#(mark(X1), X2) -> c_9(and^#(X1, X2)) , length^#(mark(X)) -> c_10(length^#(X)) , s^#(mark(X)) -> c_11(s^#(X)) , proper^#(zeros()) -> c_12() , proper^#(cons(X1, X2)) -> c_13(cons^#(proper(X1), proper(X2))) , proper^#(0()) -> c_14() , proper^#(and(X1, X2)) -> c_15(and^#(proper(X1), proper(X2))) , proper^#(tt()) -> c_16() , proper^#(length(X)) -> c_17(length^#(proper(X))) , proper^#(nil()) -> c_18() , proper^#(s(X)) -> c_19(s^#(proper(X))) , cons^#(ok(X1), ok(X2)) -> c_20(cons^#(X1, X2)) , and^#(ok(X1), ok(X2)) -> c_21(and^#(X1, X2)) , length^#(ok(X)) -> c_22(length^#(X)) , s^#(ok(X)) -> c_23(s^#(X)) , top^#(mark(X)) -> c_24(top^#(proper(X))) , top^#(ok(X)) -> c_25(top^#(active(X)))} The usable rules are: { active(zeros()) -> mark(cons(0(), zeros())) , active(and(tt(), X)) -> mark(X) , active(length(nil())) -> mark(0()) , active(length(cons(N, L))) -> mark(s(length(L))) , active(cons(X1, X2)) -> cons(active(X1), X2) , active(and(X1, X2)) -> and(active(X1), X2) , active(length(X)) -> length(active(X)) , active(s(X)) -> s(active(X)) , length(mark(X)) -> mark(length(X)) , proper(zeros()) -> ok(zeros()) , proper(cons(X1, X2)) -> cons(proper(X1), proper(X2)) , proper(0()) -> ok(0()) , proper(and(X1, X2)) -> and(proper(X1), proper(X2)) , proper(tt()) -> ok(tt()) , proper(length(X)) -> length(proper(X)) , proper(nil()) -> ok(nil()) , proper(s(X)) -> s(proper(X)) , length(ok(X)) -> ok(length(X)) , cons(mark(X1), X2) -> mark(cons(X1, X2)) , and(mark(X1), X2) -> mark(and(X1, X2)) , s(mark(X)) -> mark(s(X)) , cons(ok(X1), ok(X2)) -> ok(cons(X1, X2)) , and(ok(X1), ok(X2)) -> ok(and(X1, X2)) , s(ok(X)) -> ok(s(X))} The estimated dependency graph contains the following edges: {active^#(length(cons(N, L))) -> c_3(s^#(length(L)))} ==> {s^#(ok(X)) -> c_23(s^#(X))} {active^#(length(cons(N, L))) -> c_3(s^#(length(L)))} ==> {s^#(mark(X)) -> c_11(s^#(X))} {active^#(cons(X1, X2)) -> c_4(cons^#(active(X1), X2))} ==> {cons^#(ok(X1), ok(X2)) -> c_20(cons^#(X1, X2))} {active^#(cons(X1, X2)) -> c_4(cons^#(active(X1), X2))} ==> {cons^#(mark(X1), X2) -> c_8(cons^#(X1, X2))} {active^#(and(X1, X2)) -> c_5(and^#(active(X1), X2))} ==> {and^#(ok(X1), ok(X2)) -> c_21(and^#(X1, X2))} {active^#(and(X1, X2)) -> c_5(and^#(active(X1), X2))} ==> {and^#(mark(X1), X2) -> c_9(and^#(X1, X2))} {active^#(length(X)) -> c_6(length^#(active(X)))} ==> {length^#(ok(X)) -> c_22(length^#(X))} {active^#(length(X)) -> c_6(length^#(active(X)))} ==> {length^#(mark(X)) -> c_10(length^#(X))} {active^#(s(X)) -> c_7(s^#(active(X)))} ==> {s^#(ok(X)) -> c_23(s^#(X))} {active^#(s(X)) -> c_7(s^#(active(X)))} ==> {s^#(mark(X)) -> c_11(s^#(X))} {cons^#(mark(X1), X2) -> c_8(cons^#(X1, X2))} ==> {cons^#(ok(X1), ok(X2)) -> c_20(cons^#(X1, X2))} {cons^#(mark(X1), X2) -> c_8(cons^#(X1, X2))} ==> {cons^#(mark(X1), X2) -> c_8(cons^#(X1, X2))} {and^#(mark(X1), X2) -> c_9(and^#(X1, X2))} ==> {and^#(ok(X1), ok(X2)) -> c_21(and^#(X1, X2))} {and^#(mark(X1), X2) -> c_9(and^#(X1, X2))} ==> {and^#(mark(X1), X2) -> c_9(and^#(X1, X2))} {length^#(mark(X)) -> c_10(length^#(X))} ==> {length^#(ok(X)) -> c_22(length^#(X))} {length^#(mark(X)) -> c_10(length^#(X))} ==> {length^#(mark(X)) -> c_10(length^#(X))} {s^#(mark(X)) -> c_11(s^#(X))} ==> {s^#(ok(X)) -> c_23(s^#(X))} {s^#(mark(X)) -> c_11(s^#(X))} ==> {s^#(mark(X)) -> c_11(s^#(X))} {proper^#(cons(X1, X2)) -> c_13(cons^#(proper(X1), proper(X2)))} ==> {cons^#(ok(X1), ok(X2)) -> c_20(cons^#(X1, X2))} {proper^#(cons(X1, X2)) -> c_13(cons^#(proper(X1), proper(X2)))} ==> {cons^#(mark(X1), X2) -> c_8(cons^#(X1, X2))} {proper^#(and(X1, X2)) -> c_15(and^#(proper(X1), proper(X2)))} ==> {and^#(ok(X1), ok(X2)) -> c_21(and^#(X1, X2))} {proper^#(and(X1, X2)) -> c_15(and^#(proper(X1), proper(X2)))} ==> {and^#(mark(X1), X2) -> c_9(and^#(X1, X2))} {proper^#(length(X)) -> c_17(length^#(proper(X)))} ==> {length^#(ok(X)) -> c_22(length^#(X))} {proper^#(length(X)) -> c_17(length^#(proper(X)))} ==> {length^#(mark(X)) -> c_10(length^#(X))} {proper^#(s(X)) -> c_19(s^#(proper(X)))} ==> {s^#(ok(X)) -> c_23(s^#(X))} {proper^#(s(X)) -> c_19(s^#(proper(X)))} ==> {s^#(mark(X)) -> c_11(s^#(X))} {cons^#(ok(X1), ok(X2)) -> c_20(cons^#(X1, X2))} ==> {cons^#(ok(X1), ok(X2)) -> c_20(cons^#(X1, X2))} {cons^#(ok(X1), ok(X2)) -> c_20(cons^#(X1, X2))} ==> {cons^#(mark(X1), X2) -> c_8(cons^#(X1, X2))} {and^#(ok(X1), ok(X2)) -> c_21(and^#(X1, X2))} ==> {and^#(ok(X1), ok(X2)) -> c_21(and^#(X1, X2))} {and^#(ok(X1), ok(X2)) -> c_21(and^#(X1, X2))} ==> {and^#(mark(X1), X2) -> c_9(and^#(X1, X2))} {length^#(ok(X)) -> c_22(length^#(X))} ==> {length^#(ok(X)) -> c_22(length^#(X))} {length^#(ok(X)) -> c_22(length^#(X))} ==> {length^#(mark(X)) -> c_10(length^#(X))} {s^#(ok(X)) -> c_23(s^#(X))} ==> {s^#(ok(X)) -> c_23(s^#(X))} {s^#(ok(X)) -> c_23(s^#(X))} ==> {s^#(mark(X)) -> c_11(s^#(X))} {top^#(mark(X)) -> c_24(top^#(proper(X)))} ==> {top^#(ok(X)) -> c_25(top^#(active(X)))} {top^#(mark(X)) -> c_24(top^#(proper(X)))} ==> {top^#(mark(X)) -> c_24(top^#(proper(X)))} {top^#(ok(X)) -> c_25(top^#(active(X)))} ==> {top^#(ok(X)) -> c_25(top^#(active(X)))} {top^#(ok(X)) -> c_25(top^#(active(X)))} ==> {top^#(mark(X)) -> c_24(top^#(proper(X)))} We consider the following path(s): 1) { top^#(mark(X)) -> c_24(top^#(proper(X))) , top^#(ok(X)) -> c_25(top^#(active(X)))} The usable rules for this path are the following: { active(zeros()) -> mark(cons(0(), zeros())) , active(and(tt(), X)) -> mark(X) , active(length(nil())) -> mark(0()) , active(length(cons(N, L))) -> mark(s(length(L))) , active(cons(X1, X2)) -> cons(active(X1), X2) , active(and(X1, X2)) -> and(active(X1), X2) , active(length(X)) -> length(active(X)) , active(s(X)) -> s(active(X)) , proper(zeros()) -> ok(zeros()) , proper(cons(X1, X2)) -> cons(proper(X1), proper(X2)) , proper(0()) -> ok(0()) , proper(and(X1, X2)) -> and(proper(X1), proper(X2)) , proper(tt()) -> ok(tt()) , proper(length(X)) -> length(proper(X)) , proper(nil()) -> ok(nil()) , proper(s(X)) -> s(proper(X)) , length(mark(X)) -> mark(length(X)) , length(ok(X)) -> ok(length(X)) , cons(mark(X1), X2) -> mark(cons(X1, X2)) , and(mark(X1), X2) -> mark(and(X1, X2)) , s(mark(X)) -> mark(s(X)) , cons(ok(X1), ok(X2)) -> ok(cons(X1, X2)) , and(ok(X1), ok(X2)) -> ok(and(X1, X2)) , s(ok(X)) -> ok(s(X))} We have applied the subprocessor on the union of usable rules and weak (innermost) dependency pairs. 'Weight Gap Principle' ---------------------- Answer: YES(?,O(n^1)) Input Problem: innermost runtime-complexity with respect to Rules: { active(zeros()) -> mark(cons(0(), zeros())) , active(and(tt(), X)) -> mark(X) , active(length(nil())) -> mark(0()) , active(length(cons(N, L))) -> mark(s(length(L))) , active(cons(X1, X2)) -> cons(active(X1), X2) , active(and(X1, X2)) -> and(active(X1), X2) , active(length(X)) -> length(active(X)) , active(s(X)) -> s(active(X)) , proper(zeros()) -> ok(zeros()) , proper(cons(X1, X2)) -> cons(proper(X1), proper(X2)) , proper(0()) -> ok(0()) , proper(and(X1, X2)) -> and(proper(X1), proper(X2)) , proper(tt()) -> ok(tt()) , proper(length(X)) -> length(proper(X)) , proper(nil()) -> ok(nil()) , proper(s(X)) -> s(proper(X)) , length(mark(X)) -> mark(length(X)) , length(ok(X)) -> ok(length(X)) , cons(mark(X1), X2) -> mark(cons(X1, X2)) , and(mark(X1), X2) -> mark(and(X1, X2)) , s(mark(X)) -> mark(s(X)) , cons(ok(X1), ok(X2)) -> ok(cons(X1, X2)) , and(ok(X1), ok(X2)) -> ok(and(X1, X2)) , s(ok(X)) -> ok(s(X)) , top^#(mark(X)) -> c_24(top^#(proper(X))) , top^#(ok(X)) -> c_25(top^#(active(X)))} Details: We apply the weight gap principle, strictly orienting the rules { active(length(nil())) -> mark(0()) , cons(ok(X1), ok(X2)) -> ok(cons(X1, X2)) , and(ok(X1), ok(X2)) -> ok(and(X1, X2))} and weakly orienting the rules {} using the following strongly linear interpretation: Processor 'Matrix Interpretation' oriented the following rules strictly: { active(length(nil())) -> mark(0()) , cons(ok(X1), ok(X2)) -> ok(cons(X1, X2)) , and(ok(X1), ok(X2)) -> ok(and(X1, X2))} Details: Interpretation Functions: active(x1) = [1] x1 + [1] zeros() = [0] mark(x1) = [1] x1 + [1] cons(x1, x2) = [1] x1 + [1] x2 + [0] 0() = [0] and(x1, x2) = [1] x1 + [1] x2 + [0] tt() = [0] length(x1) = [1] x1 + [0] nil() = [8] s(x1) = [1] x1 + [0] proper(x1) = [1] x1 + [1] ok(x1) = [1] x1 + [2] top(x1) = [0] x1 + [0] active^#(x1) = [0] x1 + [0] c_0(x1) = [0] x1 + [0] cons^#(x1, x2) = [0] x1 + [0] x2 + [0] c_1() = [0] c_2() = [0] c_3(x1) = [0] x1 + [0] s^#(x1) = [0] x1 + [0] c_4(x1) = [0] x1 + [0] c_5(x1) = [0] x1 + [0] and^#(x1, x2) = [0] x1 + [0] x2 + [0] c_6(x1) = [0] x1 + [0] length^#(x1) = [0] x1 + [0] c_7(x1) = [0] x1 + [0] c_8(x1) = [0] x1 + [0] c_9(x1) = [0] x1 + [0] c_10(x1) = [0] x1 + [0] c_11(x1) = [0] x1 + [0] proper^#(x1) = [0] x1 + [0] c_12() = [0] c_13(x1) = [0] x1 + [0] c_14() = [0] c_15(x1) = [0] x1 + [0] c_16() = [0] c_17(x1) = [0] x1 + [0] c_18() = [0] c_19(x1) = [0] x1 + [0] c_20(x1) = [0] x1 + [0] c_21(x1) = [0] x1 + [0] c_22(x1) = [0] x1 + [0] c_23(x1) = [0] x1 + [0] top^#(x1) = [1] x1 + [3] c_24(x1) = [1] x1 + [5] c_25(x1) = [1] x1 + [1] Finally we apply the subprocessor We apply the weight gap principle, strictly orienting the rules {top^#(ok(X)) -> c_25(top^#(active(X)))} and weakly orienting the rules { active(length(nil())) -> mark(0()) , cons(ok(X1), ok(X2)) -> ok(cons(X1, X2)) , and(ok(X1), ok(X2)) -> ok(and(X1, X2))} using the following strongly linear interpretation: Processor 'Matrix Interpretation' oriented the following rules strictly: {top^#(ok(X)) -> c_25(top^#(active(X)))} Details: Interpretation Functions: active(x1) = [1] x1 + [1] zeros() = [0] mark(x1) = [1] x1 + [1] cons(x1, x2) = [1] x1 + [1] x2 + [0] 0() = [0] and(x1, x2) = [1] x1 + [1] x2 + [0] tt() = [0] length(x1) = [1] x1 + [0] nil() = [0] s(x1) = [1] x1 + [0] proper(x1) = [1] x1 + [1] ok(x1) = [1] x1 + [9] top(x1) = [0] x1 + [0] active^#(x1) = [0] x1 + [0] c_0(x1) = [0] x1 + [0] cons^#(x1, x2) = [0] x1 + [0] x2 + [0] c_1() = [0] c_2() = [0] c_3(x1) = [0] x1 + [0] s^#(x1) = [0] x1 + [0] c_4(x1) = [0] x1 + [0] c_5(x1) = [0] x1 + [0] and^#(x1, x2) = [0] x1 + [0] x2 + [0] c_6(x1) = [0] x1 + [0] length^#(x1) = [0] x1 + [0] c_7(x1) = [0] x1 + [0] c_8(x1) = [0] x1 + [0] c_9(x1) = [0] x1 + [0] c_10(x1) = [0] x1 + [0] c_11(x1) = [0] x1 + [0] proper^#(x1) = [0] x1 + [0] c_12() = [0] c_13(x1) = [0] x1 + [0] c_14() = [0] c_15(x1) = [0] x1 + [0] c_16() = [0] c_17(x1) = [0] x1 + [0] c_18() = [0] c_19(x1) = [0] x1 + [0] c_20(x1) = [0] x1 + [0] c_21(x1) = [0] x1 + [0] c_22(x1) = [0] x1 + [0] c_23(x1) = [0] x1 + [0] top^#(x1) = [1] x1 + [0] c_24(x1) = [1] x1 + [0] c_25(x1) = [1] x1 + [7] Finally we apply the subprocessor We apply the weight gap principle, strictly orienting the rules { proper(zeros()) -> ok(zeros()) , proper(0()) -> ok(0()) , proper(tt()) -> ok(tt()) , proper(nil()) -> ok(nil())} and weakly orienting the rules { top^#(ok(X)) -> c_25(top^#(active(X))) , active(length(nil())) -> mark(0()) , cons(ok(X1), ok(X2)) -> ok(cons(X1, X2)) , and(ok(X1), ok(X2)) -> ok(and(X1, X2))} using the following strongly linear interpretation: Processor 'Matrix Interpretation' oriented the following rules strictly: { proper(zeros()) -> ok(zeros()) , proper(0()) -> ok(0()) , proper(tt()) -> ok(tt()) , proper(nil()) -> ok(nil())} Details: Interpretation Functions: active(x1) = [1] x1 + [1] zeros() = [0] mark(x1) = [1] x1 + [1] cons(x1, x2) = [1] x1 + [1] x2 + [0] 0() = [0] and(x1, x2) = [1] x1 + [1] x2 + [0] tt() = [0] length(x1) = [1] x1 + [0] nil() = [9] s(x1) = [1] x1 + [4] proper(x1) = [1] x1 + [8] ok(x1) = [1] x1 + [7] top(x1) = [0] x1 + [0] active^#(x1) = [0] x1 + [0] c_0(x1) = [0] x1 + [0] cons^#(x1, x2) = [0] x1 + [0] x2 + [0] c_1() = [0] c_2() = [0] c_3(x1) = [0] x1 + [0] s^#(x1) = [0] x1 + [0] c_4(x1) = [0] x1 + [0] c_5(x1) = [0] x1 + [0] and^#(x1, x2) = [0] x1 + [0] x2 + [0] c_6(x1) = [0] x1 + [0] length^#(x1) = [0] x1 + [0] c_7(x1) = [0] x1 + [0] c_8(x1) = [0] x1 + [0] c_9(x1) = [0] x1 + [0] c_10(x1) = [0] x1 + [0] c_11(x1) = [0] x1 + [0] proper^#(x1) = [0] x1 + [0] c_12() = [0] c_13(x1) = [0] x1 + [0] c_14() = [0] c_15(x1) = [0] x1 + [0] c_16() = [0] c_17(x1) = [0] x1 + [0] c_18() = [0] c_19(x1) = [0] x1 + [0] c_20(x1) = [0] x1 + [0] c_21(x1) = [0] x1 + [0] c_22(x1) = [0] x1 + [0] c_23(x1) = [0] x1 + [0] top^#(x1) = [1] x1 + [1] c_24(x1) = [1] x1 + [1] c_25(x1) = [1] x1 + [6] Finally we apply the subprocessor We apply the weight gap principle, strictly orienting the rules { active(and(tt(), X)) -> mark(X) , active(length(cons(N, L))) -> mark(s(length(L)))} and weakly orienting the rules { proper(zeros()) -> ok(zeros()) , proper(0()) -> ok(0()) , proper(tt()) -> ok(tt()) , proper(nil()) -> ok(nil()) , top^#(ok(X)) -> c_25(top^#(active(X))) , active(length(nil())) -> mark(0()) , cons(ok(X1), ok(X2)) -> ok(cons(X1, X2)) , and(ok(X1), ok(X2)) -> ok(and(X1, X2))} using the following strongly linear interpretation: Processor 'Matrix Interpretation' oriented the following rules strictly: { active(and(tt(), X)) -> mark(X) , active(length(cons(N, L))) -> mark(s(length(L)))} Details: Interpretation Functions: active(x1) = [1] x1 + [0] zeros() = [15] mark(x1) = [1] x1 + [0] cons(x1, x2) = [1] x1 + [1] x2 + [2] 0() = [1] and(x1, x2) = [1] x1 + [1] x2 + [10] tt() = [0] length(x1) = [1] x1 + [6] nil() = [2] s(x1) = [1] x1 + [0] proper(x1) = [1] x1 + [9] ok(x1) = [1] x1 + [8] top(x1) = [0] x1 + [0] active^#(x1) = [0] x1 + [0] c_0(x1) = [0] x1 + [0] cons^#(x1, x2) = [0] x1 + [0] x2 + [0] c_1() = [0] c_2() = [0] c_3(x1) = [0] x1 + [0] s^#(x1) = [0] x1 + [0] c_4(x1) = [0] x1 + [0] c_5(x1) = [0] x1 + [0] and^#(x1, x2) = [0] x1 + [0] x2 + [0] c_6(x1) = [0] x1 + [0] length^#(x1) = [0] x1 + [0] c_7(x1) = [0] x1 + [0] c_8(x1) = [0] x1 + [0] c_9(x1) = [0] x1 + [0] c_10(x1) = [0] x1 + [0] c_11(x1) = [0] x1 + [0] proper^#(x1) = [0] x1 + [0] c_12() = [0] c_13(x1) = [0] x1 + [0] c_14() = [0] c_15(x1) = [0] x1 + [0] c_16() = [0] c_17(x1) = [0] x1 + [0] c_18() = [0] c_19(x1) = [0] x1 + [0] c_20(x1) = [0] x1 + [0] c_21(x1) = [0] x1 + [0] c_22(x1) = [0] x1 + [0] c_23(x1) = [0] x1 + [0] top^#(x1) = [1] x1 + [8] c_24(x1) = [1] x1 + [2] c_25(x1) = [1] x1 + [0] Finally we apply the subprocessor We apply the weight gap principle, strictly orienting the rules {top^#(mark(X)) -> c_24(top^#(proper(X)))} and weakly orienting the rules { active(and(tt(), X)) -> mark(X) , active(length(cons(N, L))) -> mark(s(length(L))) , proper(zeros()) -> ok(zeros()) , proper(0()) -> ok(0()) , proper(tt()) -> ok(tt()) , proper(nil()) -> ok(nil()) , top^#(ok(X)) -> c_25(top^#(active(X))) , active(length(nil())) -> mark(0()) , cons(ok(X1), ok(X2)) -> ok(cons(X1, X2)) , and(ok(X1), ok(X2)) -> ok(and(X1, X2))} using the following strongly linear interpretation: Processor 'Matrix Interpretation' oriented the following rules strictly: {top^#(mark(X)) -> c_24(top^#(proper(X)))} Details: Interpretation Functions: active(x1) = [1] x1 + [0] zeros() = [0] mark(x1) = [1] x1 + [1] cons(x1, x2) = [1] x1 + [1] x2 + [1] 0() = [0] and(x1, x2) = [1] x1 + [1] x2 + [0] tt() = [4] length(x1) = [1] x1 + [0] nil() = [8] s(x1) = [1] x1 + [0] proper(x1) = [1] x1 + [0] ok(x1) = [1] x1 + [0] top(x1) = [0] x1 + [0] active^#(x1) = [0] x1 + [0] c_0(x1) = [0] x1 + [0] cons^#(x1, x2) = [0] x1 + [0] x2 + [0] c_1() = [0] c_2() = [0] c_3(x1) = [0] x1 + [0] s^#(x1) = [0] x1 + [0] c_4(x1) = [0] x1 + [0] c_5(x1) = [0] x1 + [0] and^#(x1, x2) = [0] x1 + [0] x2 + [0] c_6(x1) = [0] x1 + [0] length^#(x1) = [0] x1 + [0] c_7(x1) = [0] x1 + [0] c_8(x1) = [0] x1 + [0] c_9(x1) = [0] x1 + [0] c_10(x1) = [0] x1 + [0] c_11(x1) = [0] x1 + [0] proper^#(x1) = [0] x1 + [0] c_12() = [0] c_13(x1) = [0] x1 + [0] c_14() = [0] c_15(x1) = [0] x1 + [0] c_16() = [0] c_17(x1) = [0] x1 + [0] c_18() = [0] c_19(x1) = [0] x1 + [0] c_20(x1) = [0] x1 + [0] c_21(x1) = [0] x1 + [0] c_22(x1) = [0] x1 + [0] c_23(x1) = [0] x1 + [0] top^#(x1) = [1] x1 + [7] c_24(x1) = [1] x1 + [0] c_25(x1) = [1] x1 + [0] Finally we apply the subprocessor 'fastest of 'combine', 'Bounds with default enrichment', 'Bounds with default enrichment'' ------------------------------------------------------------------------------------------ Answer: YES(?,O(n^1)) Input Problem: innermost relative runtime-complexity with respect to Strict Rules: { active(zeros()) -> mark(cons(0(), zeros())) , active(cons(X1, X2)) -> cons(active(X1), X2) , active(and(X1, X2)) -> and(active(X1), X2) , active(length(X)) -> length(active(X)) , active(s(X)) -> s(active(X)) , proper(cons(X1, X2)) -> cons(proper(X1), proper(X2)) , proper(and(X1, X2)) -> and(proper(X1), proper(X2)) , proper(length(X)) -> length(proper(X)) , proper(s(X)) -> s(proper(X)) , length(mark(X)) -> mark(length(X)) , length(ok(X)) -> ok(length(X)) , cons(mark(X1), X2) -> mark(cons(X1, X2)) , and(mark(X1), X2) -> mark(and(X1, X2)) , s(mark(X)) -> mark(s(X)) , s(ok(X)) -> ok(s(X))} Weak Rules: { top^#(mark(X)) -> c_24(top^#(proper(X))) , active(and(tt(), X)) -> mark(X) , active(length(cons(N, L))) -> mark(s(length(L))) , proper(zeros()) -> ok(zeros()) , proper(0()) -> ok(0()) , proper(tt()) -> ok(tt()) , proper(nil()) -> ok(nil()) , top^#(ok(X)) -> c_25(top^#(active(X))) , active(length(nil())) -> mark(0()) , cons(ok(X1), ok(X2)) -> ok(cons(X1, X2)) , and(ok(X1), ok(X2)) -> ok(and(X1, X2))} Details: The problem was solved by processor 'Bounds with default enrichment': 'Bounds with default enrichment' -------------------------------- Answer: YES(?,O(n^1)) Input Problem: innermost relative runtime-complexity with respect to Strict Rules: { active(zeros()) -> mark(cons(0(), zeros())) , active(cons(X1, X2)) -> cons(active(X1), X2) , active(and(X1, X2)) -> and(active(X1), X2) , active(length(X)) -> length(active(X)) , active(s(X)) -> s(active(X)) , proper(cons(X1, X2)) -> cons(proper(X1), proper(X2)) , proper(and(X1, X2)) -> and(proper(X1), proper(X2)) , proper(length(X)) -> length(proper(X)) , proper(s(X)) -> s(proper(X)) , length(mark(X)) -> mark(length(X)) , length(ok(X)) -> ok(length(X)) , cons(mark(X1), X2) -> mark(cons(X1, X2)) , and(mark(X1), X2) -> mark(and(X1, X2)) , s(mark(X)) -> mark(s(X)) , s(ok(X)) -> ok(s(X))} Weak Rules: { top^#(mark(X)) -> c_24(top^#(proper(X))) , active(and(tt(), X)) -> mark(X) , active(length(cons(N, L))) -> mark(s(length(L))) , proper(zeros()) -> ok(zeros()) , proper(0()) -> ok(0()) , proper(tt()) -> ok(tt()) , proper(nil()) -> ok(nil()) , top^#(ok(X)) -> c_25(top^#(active(X))) , active(length(nil())) -> mark(0()) , cons(ok(X1), ok(X2)) -> ok(cons(X1, X2)) , and(ok(X1), ok(X2)) -> ok(and(X1, X2))} Details: The problem is Match-bounded by 4. The enriched problem is compatible with the following automaton: { active_0(2) -> 6 , active_1(2) -> 15 , active_1(8) -> 17 , active_1(9) -> 17 , active_2(8) -> 28 , active_2(9) -> 28 , active_2(18) -> 36 , active_3(18) -> 40 , active_3(19) -> 38 , active_3(37) -> 42 , active_4(34) -> 43 , active_4(37) -> 45 , zeros_0() -> 2 , zeros_1() -> 9 , zeros_2() -> 20 , zeros_3() -> 33 , mark_0(2) -> 2 , mark_1(7) -> 6 , mark_1(7) -> 15 , mark_2(18) -> 17 , mark_2(18) -> 28 , cons_1(8, 9) -> 7 , cons_2(19, 20) -> 18 , cons_2(21, 22) -> 13 , cons_2(21, 22) -> 24 , cons_3(29, 30) -> 26 , cons_3(29, 30) -> 32 , cons_3(34, 33) -> 37 , cons_3(38, 20) -> 36 , cons_3(38, 20) -> 40 , cons_4(43, 33) -> 42 , cons_4(43, 33) -> 45 , 0_0() -> 2 , 0_1() -> 8 , 0_2() -> 19 , 0_3() -> 34 , tt_0() -> 2 , tt_1() -> 8 , tt_2() -> 19 , tt_3() -> 34 , nil_0() -> 2 , nil_1() -> 8 , nil_2() -> 19 , nil_3() -> 34 , proper_0(2) -> 4 , proper_1(2) -> 11 , proper_1(7) -> 13 , proper_2(7) -> 24 , proper_2(8) -> 21 , proper_2(9) -> 22 , proper_2(18) -> 26 , proper_3(18) -> 32 , proper_3(19) -> 29 , proper_3(20) -> 30 , ok_0(2) -> 2 , ok_0(2) -> 4 , ok_1(8) -> 11 , ok_1(9) -> 11 , ok_2(18) -> 13 , ok_2(18) -> 24 , ok_2(19) -> 21 , ok_2(20) -> 22 , ok_3(33) -> 30 , ok_3(34) -> 29 , ok_3(37) -> 26 , ok_3(37) -> 32 , top^#_0(2) -> 1 , top^#_0(4) -> 3 , top^#_0(6) -> 5 , top^#_1(11) -> 10 , top^#_1(13) -> 12 , top^#_1(15) -> 14 , top^#_1(17) -> 16 , top^#_2(24) -> 23 , top^#_2(26) -> 25 , top^#_2(28) -> 27 , top^#_2(36) -> 35 , top^#_3(32) -> 31 , top^#_3(40) -> 39 , top^#_3(42) -> 41 , top^#_4(45) -> 44 , c_24_0(3) -> 1 , c_24_1(10) -> 1 , c_24_1(12) -> 5 , c_24_2(23) -> 14 , c_24_2(25) -> 16 , c_24_3(31) -> 27 , c_25_0(5) -> 1 , c_25_0(5) -> 3 , c_25_1(14) -> 1 , c_25_1(14) -> 3 , c_25_1(16) -> 10 , c_25_2(27) -> 10 , c_25_2(35) -> 12 , c_25_3(39) -> 23 , c_25_3(41) -> 25 , c_25_4(44) -> 31} 2) { active^#(cons(X1, X2)) -> c_4(cons^#(active(X1), X2)) , cons^#(ok(X1), ok(X2)) -> c_20(cons^#(X1, X2)) , cons^#(mark(X1), X2) -> c_8(cons^#(X1, X2))} The usable rules for this path are the following: { active(zeros()) -> mark(cons(0(), zeros())) , active(and(tt(), X)) -> mark(X) , active(length(nil())) -> mark(0()) , active(length(cons(N, L))) -> mark(s(length(L))) , active(cons(X1, X2)) -> cons(active(X1), X2) , active(and(X1, X2)) -> and(active(X1), X2) , active(length(X)) -> length(active(X)) , active(s(X)) -> s(active(X)) , length(mark(X)) -> mark(length(X)) , length(ok(X)) -> ok(length(X)) , cons(mark(X1), X2) -> mark(cons(X1, X2)) , and(mark(X1), X2) -> mark(and(X1, X2)) , s(mark(X)) -> mark(s(X)) , cons(ok(X1), ok(X2)) -> ok(cons(X1, X2)) , and(ok(X1), ok(X2)) -> ok(and(X1, X2)) , s(ok(X)) -> ok(s(X))} We have applied the subprocessor on the union of usable rules and weak (innermost) dependency pairs. 'Weight Gap Principle' ---------------------- Answer: YES(?,O(n^1)) Input Problem: innermost runtime-complexity with respect to Rules: { active(zeros()) -> mark(cons(0(), zeros())) , active(and(tt(), X)) -> mark(X) , active(length(nil())) -> mark(0()) , active(length(cons(N, L))) -> mark(s(length(L))) , active(cons(X1, X2)) -> cons(active(X1), X2) , active(and(X1, X2)) -> and(active(X1), X2) , active(length(X)) -> length(active(X)) , active(s(X)) -> s(active(X)) , length(mark(X)) -> mark(length(X)) , length(ok(X)) -> ok(length(X)) , cons(mark(X1), X2) -> mark(cons(X1, X2)) , and(mark(X1), X2) -> mark(and(X1, X2)) , s(mark(X)) -> mark(s(X)) , cons(ok(X1), ok(X2)) -> ok(cons(X1, X2)) , and(ok(X1), ok(X2)) -> ok(and(X1, X2)) , s(ok(X)) -> ok(s(X)) , active^#(cons(X1, X2)) -> c_4(cons^#(active(X1), X2)) , cons^#(ok(X1), ok(X2)) -> c_20(cons^#(X1, X2)) , cons^#(mark(X1), X2) -> c_8(cons^#(X1, X2))} Details: We apply the weight gap principle, strictly orienting the rules {cons^#(mark(X1), X2) -> c_8(cons^#(X1, X2))} and weakly orienting the rules {} using the following strongly linear interpretation: Processor 'Matrix Interpretation' oriented the following rules strictly: {cons^#(mark(X1), X2) -> c_8(cons^#(X1, X2))} Details: Interpretation Functions: active(x1) = [1] x1 + [1] zeros() = [0] mark(x1) = [1] x1 + [1] cons(x1, x2) = [1] x1 + [1] x2 + [0] 0() = [0] and(x1, x2) = [1] x1 + [1] x2 + [0] tt() = [0] length(x1) = [1] x1 + [0] nil() = [0] s(x1) = [1] x1 + [0] proper(x1) = [0] x1 + [0] ok(x1) = [1] x1 + [0] top(x1) = [0] x1 + [0] active^#(x1) = [1] x1 + [1] c_0(x1) = [0] x1 + [0] cons^#(x1, x2) = [1] x1 + [1] x2 + [0] c_1() = [0] c_2() = [0] c_3(x1) = [0] x1 + [0] s^#(x1) = [0] x1 + [0] c_4(x1) = [1] x1 + [0] c_5(x1) = [0] x1 + [0] and^#(x1, x2) = [0] x1 + [0] x2 + [0] c_6(x1) = [0] x1 + [0] length^#(x1) = [0] x1 + [0] c_7(x1) = [0] x1 + [0] c_8(x1) = [1] x1 + [0] c_9(x1) = [0] x1 + [0] c_10(x1) = [0] x1 + [0] c_11(x1) = [0] x1 + [0] proper^#(x1) = [0] x1 + [0] c_12() = [0] c_13(x1) = [0] x1 + [0] c_14() = [0] c_15(x1) = [0] x1 + [0] c_16() = [0] c_17(x1) = [0] x1 + [0] c_18() = [0] c_19(x1) = [0] x1 + [0] c_20(x1) = [1] x1 + [1] c_21(x1) = [0] x1 + [0] c_22(x1) = [0] x1 + [0] c_23(x1) = [0] x1 + [0] top^#(x1) = [0] x1 + [0] c_24(x1) = [0] x1 + [0] c_25(x1) = [0] x1 + [0] Finally we apply the subprocessor We apply the weight gap principle, strictly orienting the rules {active^#(cons(X1, X2)) -> c_4(cons^#(active(X1), X2))} and weakly orienting the rules {cons^#(mark(X1), X2) -> c_8(cons^#(X1, X2))} using the following strongly linear interpretation: Processor 'Matrix Interpretation' oriented the following rules strictly: {active^#(cons(X1, X2)) -> c_4(cons^#(active(X1), X2))} Details: Interpretation Functions: active(x1) = [1] x1 + [1] zeros() = [0] mark(x1) = [1] x1 + [1] cons(x1, x2) = [1] x1 + [1] x2 + [0] 0() = [0] and(x1, x2) = [1] x1 + [1] x2 + [0] tt() = [0] length(x1) = [1] x1 + [0] nil() = [0] s(x1) = [1] x1 + [0] proper(x1) = [0] x1 + [0] ok(x1) = [1] x1 + [0] top(x1) = [0] x1 + [0] active^#(x1) = [1] x1 + [9] c_0(x1) = [0] x1 + [0] cons^#(x1, x2) = [1] x1 + [1] x2 + [0] c_1() = [0] c_2() = [0] c_3(x1) = [0] x1 + [0] s^#(x1) = [0] x1 + [0] c_4(x1) = [1] x1 + [0] c_5(x1) = [0] x1 + [0] and^#(x1, x2) = [0] x1 + [0] x2 + [0] c_6(x1) = [0] x1 + [0] length^#(x1) = [0] x1 + [0] c_7(x1) = [0] x1 + [0] c_8(x1) = [1] x1 + [1] c_9(x1) = [0] x1 + [0] c_10(x1) = [0] x1 + [0] c_11(x1) = [0] x1 + [0] proper^#(x1) = [0] x1 + [0] c_12() = [0] c_13(x1) = [0] x1 + [0] c_14() = [0] c_15(x1) = [0] x1 + [0] c_16() = [0] c_17(x1) = [0] x1 + [0] c_18() = [0] c_19(x1) = [0] x1 + [0] c_20(x1) = [1] x1 + [1] c_21(x1) = [0] x1 + [0] c_22(x1) = [0] x1 + [0] c_23(x1) = [0] x1 + [0] top^#(x1) = [0] x1 + [0] c_24(x1) = [0] x1 + [0] c_25(x1) = [0] x1 + [0] Finally we apply the subprocessor We apply the weight gap principle, strictly orienting the rules { cons(ok(X1), ok(X2)) -> ok(cons(X1, X2)) , and(ok(X1), ok(X2)) -> ok(and(X1, X2)) , cons^#(ok(X1), ok(X2)) -> c_20(cons^#(X1, X2))} and weakly orienting the rules { active^#(cons(X1, X2)) -> c_4(cons^#(active(X1), X2)) , cons^#(mark(X1), X2) -> c_8(cons^#(X1, X2))} using the following strongly linear interpretation: Processor 'Matrix Interpretation' oriented the following rules strictly: { cons(ok(X1), ok(X2)) -> ok(cons(X1, X2)) , and(ok(X1), ok(X2)) -> ok(and(X1, X2)) , cons^#(ok(X1), ok(X2)) -> c_20(cons^#(X1, X2))} Details: Interpretation Functions: active(x1) = [1] x1 + [1] zeros() = [0] mark(x1) = [1] x1 + [1] cons(x1, x2) = [1] x1 + [1] x2 + [0] 0() = [0] and(x1, x2) = [1] x1 + [1] x2 + [0] tt() = [0] length(x1) = [1] x1 + [0] nil() = [0] s(x1) = [1] x1 + [0] proper(x1) = [0] x1 + [0] ok(x1) = [1] x1 + [4] top(x1) = [0] x1 + [0] active^#(x1) = [1] x1 + [1] c_0(x1) = [0] x1 + [0] cons^#(x1, x2) = [1] x1 + [1] x2 + [0] c_1() = [0] c_2() = [0] c_3(x1) = [0] x1 + [0] s^#(x1) = [0] x1 + [0] c_4(x1) = [1] x1 + [0] c_5(x1) = [0] x1 + [0] and^#(x1, x2) = [0] x1 + [0] x2 + [0] c_6(x1) = [0] x1 + [0] length^#(x1) = [0] x1 + [0] c_7(x1) = [0] x1 + [0] c_8(x1) = [1] x1 + [1] c_9(x1) = [0] x1 + [0] c_10(x1) = [0] x1 + [0] c_11(x1) = [0] x1 + [0] proper^#(x1) = [0] x1 + [0] c_12() = [0] c_13(x1) = [0] x1 + [0] c_14() = [0] c_15(x1) = [0] x1 + [0] c_16() = [0] c_17(x1) = [0] x1 + [0] c_18() = [0] c_19(x1) = [0] x1 + [0] c_20(x1) = [1] x1 + [0] c_21(x1) = [0] x1 + [0] c_22(x1) = [0] x1 + [0] c_23(x1) = [0] x1 + [0] top^#(x1) = [0] x1 + [0] c_24(x1) = [0] x1 + [0] c_25(x1) = [0] x1 + [0] Finally we apply the subprocessor We apply the weight gap principle, strictly orienting the rules {active(length(nil())) -> mark(0())} and weakly orienting the rules { cons(ok(X1), ok(X2)) -> ok(cons(X1, X2)) , and(ok(X1), ok(X2)) -> ok(and(X1, X2)) , cons^#(ok(X1), ok(X2)) -> c_20(cons^#(X1, X2)) , active^#(cons(X1, X2)) -> c_4(cons^#(active(X1), X2)) , cons^#(mark(X1), X2) -> c_8(cons^#(X1, X2))} using the following strongly linear interpretation: Processor 'Matrix Interpretation' oriented the following rules strictly: {active(length(nil())) -> mark(0())} Details: Interpretation Functions: active(x1) = [1] x1 + [1] zeros() = [0] mark(x1) = [1] x1 + [1] cons(x1, x2) = [1] x1 + [1] x2 + [0] 0() = [0] and(x1, x2) = [1] x1 + [1] x2 + [0] tt() = [0] length(x1) = [1] x1 + [12] nil() = [0] s(x1) = [1] x1 + [11] proper(x1) = [0] x1 + [0] ok(x1) = [1] x1 + [5] top(x1) = [0] x1 + [0] active^#(x1) = [1] x1 + [9] c_0(x1) = [0] x1 + [0] cons^#(x1, x2) = [1] x1 + [1] x2 + [8] c_1() = [0] c_2() = [0] c_3(x1) = [0] x1 + [0] s^#(x1) = [0] x1 + [0] c_4(x1) = [1] x1 + [0] c_5(x1) = [0] x1 + [0] and^#(x1, x2) = [0] x1 + [0] x2 + [0] c_6(x1) = [0] x1 + [0] length^#(x1) = [0] x1 + [0] c_7(x1) = [0] x1 + [0] c_8(x1) = [1] x1 + [1] c_9(x1) = [0] x1 + [0] c_10(x1) = [0] x1 + [0] c_11(x1) = [0] x1 + [0] proper^#(x1) = [0] x1 + [0] c_12() = [0] c_13(x1) = [0] x1 + [0] c_14() = [0] c_15(x1) = [0] x1 + [0] c_16() = [0] c_17(x1) = [0] x1 + [0] c_18() = [0] c_19(x1) = [0] x1 + [0] c_20(x1) = [1] x1 + [1] c_21(x1) = [0] x1 + [0] c_22(x1) = [0] x1 + [0] c_23(x1) = [0] x1 + [0] top^#(x1) = [0] x1 + [0] c_24(x1) = [0] x1 + [0] c_25(x1) = [0] x1 + [0] Finally we apply the subprocessor We apply the weight gap principle, strictly orienting the rules {active(and(tt(), X)) -> mark(X)} and weakly orienting the rules { active(length(nil())) -> mark(0()) , cons(ok(X1), ok(X2)) -> ok(cons(X1, X2)) , and(ok(X1), ok(X2)) -> ok(and(X1, X2)) , cons^#(ok(X1), ok(X2)) -> c_20(cons^#(X1, X2)) , active^#(cons(X1, X2)) -> c_4(cons^#(active(X1), X2)) , cons^#(mark(X1), X2) -> c_8(cons^#(X1, X2))} using the following strongly linear interpretation: Processor 'Matrix Interpretation' oriented the following rules strictly: {active(and(tt(), X)) -> mark(X)} Details: Interpretation Functions: active(x1) = [1] x1 + [0] zeros() = [1] mark(x1) = [1] x1 + [8] cons(x1, x2) = [1] x1 + [1] x2 + [8] 0() = [4] and(x1, x2) = [1] x1 + [1] x2 + [12] tt() = [0] length(x1) = [1] x1 + [0] nil() = [12] s(x1) = [1] x1 + [0] proper(x1) = [0] x1 + [0] ok(x1) = [1] x1 + [0] top(x1) = [0] x1 + [0] active^#(x1) = [1] x1 + [13] c_0(x1) = [0] x1 + [0] cons^#(x1, x2) = [1] x1 + [1] x2 + [9] c_1() = [0] c_2() = [0] c_3(x1) = [0] x1 + [0] s^#(x1) = [0] x1 + [0] c_4(x1) = [1] x1 + [8] c_5(x1) = [0] x1 + [0] and^#(x1, x2) = [0] x1 + [0] x2 + [0] c_6(x1) = [0] x1 + [0] length^#(x1) = [0] x1 + [0] c_7(x1) = [0] x1 + [0] c_8(x1) = [1] x1 + [7] c_9(x1) = [0] x1 + [0] c_10(x1) = [0] x1 + [0] c_11(x1) = [0] x1 + [0] proper^#(x1) = [0] x1 + [0] c_12() = [0] c_13(x1) = [0] x1 + [0] c_14() = [0] c_15(x1) = [0] x1 + [0] c_16() = [0] c_17(x1) = [0] x1 + [0] c_18() = [0] c_19(x1) = [0] x1 + [0] c_20(x1) = [1] x1 + [0] c_21(x1) = [0] x1 + [0] c_22(x1) = [0] x1 + [0] c_23(x1) = [0] x1 + [0] top^#(x1) = [0] x1 + [0] c_24(x1) = [0] x1 + [0] c_25(x1) = [0] x1 + [0] Finally we apply the subprocessor We apply the weight gap principle, strictly orienting the rules {active(length(cons(N, L))) -> mark(s(length(L)))} and weakly orienting the rules { active(and(tt(), X)) -> mark(X) , active(length(nil())) -> mark(0()) , cons(ok(X1), ok(X2)) -> ok(cons(X1, X2)) , and(ok(X1), ok(X2)) -> ok(and(X1, X2)) , cons^#(ok(X1), ok(X2)) -> c_20(cons^#(X1, X2)) , active^#(cons(X1, X2)) -> c_4(cons^#(active(X1), X2)) , cons^#(mark(X1), X2) -> c_8(cons^#(X1, X2))} using the following strongly linear interpretation: Processor 'Matrix Interpretation' oriented the following rules strictly: {active(length(cons(N, L))) -> mark(s(length(L)))} Details: Interpretation Functions: active(x1) = [1] x1 + [1] zeros() = [0] mark(x1) = [1] x1 + [0] cons(x1, x2) = [1] x1 + [1] x2 + [4] 0() = [5] and(x1, x2) = [1] x1 + [1] x2 + [1] tt() = [14] length(x1) = [1] x1 + [0] nil() = [6] s(x1) = [1] x1 + [0] proper(x1) = [0] x1 + [0] ok(x1) = [1] x1 + [4] top(x1) = [0] x1 + [0] active^#(x1) = [1] x1 + [13] c_0(x1) = [0] x1 + [0] cons^#(x1, x2) = [1] x1 + [1] x2 + [0] c_1() = [0] c_2() = [0] c_3(x1) = [0] x1 + [0] s^#(x1) = [0] x1 + [0] c_4(x1) = [1] x1 + [0] c_5(x1) = [0] x1 + [0] and^#(x1, x2) = [0] x1 + [0] x2 + [0] c_6(x1) = [0] x1 + [0] length^#(x1) = [0] x1 + [0] c_7(x1) = [0] x1 + [0] c_8(x1) = [1] x1 + [0] c_9(x1) = [0] x1 + [0] c_10(x1) = [0] x1 + [0] c_11(x1) = [0] x1 + [0] proper^#(x1) = [0] x1 + [0] c_12() = [0] c_13(x1) = [0] x1 + [0] c_14() = [0] c_15(x1) = [0] x1 + [0] c_16() = [0] c_17(x1) = [0] x1 + [0] c_18() = [0] c_19(x1) = [0] x1 + [0] c_20(x1) = [1] x1 + [1] c_21(x1) = [0] x1 + [0] c_22(x1) = [0] x1 + [0] c_23(x1) = [0] x1 + [0] top^#(x1) = [0] x1 + [0] c_24(x1) = [0] x1 + [0] c_25(x1) = [0] x1 + [0] Finally we apply the subprocessor We apply the weight gap principle, strictly orienting the rules {active(zeros()) -> mark(cons(0(), zeros()))} and weakly orienting the rules { active(length(cons(N, L))) -> mark(s(length(L))) , active(and(tt(), X)) -> mark(X) , active(length(nil())) -> mark(0()) , cons(ok(X1), ok(X2)) -> ok(cons(X1, X2)) , and(ok(X1), ok(X2)) -> ok(and(X1, X2)) , cons^#(ok(X1), ok(X2)) -> c_20(cons^#(X1, X2)) , active^#(cons(X1, X2)) -> c_4(cons^#(active(X1), X2)) , cons^#(mark(X1), X2) -> c_8(cons^#(X1, X2))} using the following strongly linear interpretation: Processor 'Matrix Interpretation' oriented the following rules strictly: {active(zeros()) -> mark(cons(0(), zeros()))} Details: Interpretation Functions: active(x1) = [1] x1 + [1] zeros() = [15] mark(x1) = [1] x1 + [0] cons(x1, x2) = [1] x1 + [1] x2 + [0] 0() = [0] and(x1, x2) = [1] x1 + [1] x2 + [0] tt() = [15] length(x1) = [1] x1 + [0] nil() = [4] s(x1) = [1] x1 + [0] proper(x1) = [0] x1 + [0] ok(x1) = [1] x1 + [0] top(x1) = [0] x1 + [0] active^#(x1) = [1] x1 + [1] c_0(x1) = [0] x1 + [0] cons^#(x1, x2) = [1] x1 + [1] x2 + [0] c_1() = [0] c_2() = [0] c_3(x1) = [0] x1 + [0] s^#(x1) = [0] x1 + [0] c_4(x1) = [1] x1 + [0] c_5(x1) = [0] x1 + [0] and^#(x1, x2) = [0] x1 + [0] x2 + [0] c_6(x1) = [0] x1 + [0] length^#(x1) = [0] x1 + [0] c_7(x1) = [0] x1 + [0] c_8(x1) = [1] x1 + [0] c_9(x1) = [0] x1 + [0] c_10(x1) = [0] x1 + [0] c_11(x1) = [0] x1 + [0] proper^#(x1) = [0] x1 + [0] c_12() = [0] c_13(x1) = [0] x1 + [0] c_14() = [0] c_15(x1) = [0] x1 + [0] c_16() = [0] c_17(x1) = [0] x1 + [0] c_18() = [0] c_19(x1) = [0] x1 + [0] c_20(x1) = [1] x1 + [0] c_21(x1) = [0] x1 + [0] c_22(x1) = [0] x1 + [0] c_23(x1) = [0] x1 + [0] top^#(x1) = [0] x1 + [0] c_24(x1) = [0] x1 + [0] c_25(x1) = [0] x1 + [0] Finally we apply the subprocessor 'fastest of 'combine', 'Bounds with default enrichment', 'Bounds with default enrichment'' ------------------------------------------------------------------------------------------ Answer: YES(?,O(n^1)) Input Problem: innermost relative runtime-complexity with respect to Strict Rules: { active(cons(X1, X2)) -> cons(active(X1), X2) , active(and(X1, X2)) -> and(active(X1), X2) , active(length(X)) -> length(active(X)) , active(s(X)) -> s(active(X)) , length(mark(X)) -> mark(length(X)) , length(ok(X)) -> ok(length(X)) , cons(mark(X1), X2) -> mark(cons(X1, X2)) , and(mark(X1), X2) -> mark(and(X1, X2)) , s(mark(X)) -> mark(s(X)) , s(ok(X)) -> ok(s(X))} Weak Rules: { active(zeros()) -> mark(cons(0(), zeros())) , active(length(cons(N, L))) -> mark(s(length(L))) , active(and(tt(), X)) -> mark(X) , active(length(nil())) -> mark(0()) , cons(ok(X1), ok(X2)) -> ok(cons(X1, X2)) , and(ok(X1), ok(X2)) -> ok(and(X1, X2)) , cons^#(ok(X1), ok(X2)) -> c_20(cons^#(X1, X2)) , active^#(cons(X1, X2)) -> c_4(cons^#(active(X1), X2)) , cons^#(mark(X1), X2) -> c_8(cons^#(X1, X2))} Details: The problem was solved by processor 'Bounds with default enrichment': 'Bounds with default enrichment' -------------------------------- Answer: YES(?,O(n^1)) Input Problem: innermost relative runtime-complexity with respect to Strict Rules: { active(cons(X1, X2)) -> cons(active(X1), X2) , active(and(X1, X2)) -> and(active(X1), X2) , active(length(X)) -> length(active(X)) , active(s(X)) -> s(active(X)) , length(mark(X)) -> mark(length(X)) , length(ok(X)) -> ok(length(X)) , cons(mark(X1), X2) -> mark(cons(X1, X2)) , and(mark(X1), X2) -> mark(and(X1, X2)) , s(mark(X)) -> mark(s(X)) , s(ok(X)) -> ok(s(X))} Weak Rules: { active(zeros()) -> mark(cons(0(), zeros())) , active(length(cons(N, L))) -> mark(s(length(L))) , active(and(tt(), X)) -> mark(X) , active(length(nil())) -> mark(0()) , cons(ok(X1), ok(X2)) -> ok(cons(X1, X2)) , and(ok(X1), ok(X2)) -> ok(and(X1, X2)) , cons^#(ok(X1), ok(X2)) -> c_20(cons^#(X1, X2)) , active^#(cons(X1, X2)) -> c_4(cons^#(active(X1), X2)) , cons^#(mark(X1), X2) -> c_8(cons^#(X1, X2))} Details: The problem is Match-bounded by 0. The enriched problem is compatible with the following automaton: { zeros_0() -> 2 , mark_0(2) -> 2 , 0_0() -> 2 , tt_0() -> 2 , nil_0() -> 2 , ok_0(2) -> 2 , active^#_0(2) -> 1 , cons^#_0(2, 2) -> 1 , c_8_0(1) -> 1 , c_20_0(1) -> 1} 3) { active^#(and(X1, X2)) -> c_5(and^#(active(X1), X2)) , and^#(ok(X1), ok(X2)) -> c_21(and^#(X1, X2)) , and^#(mark(X1), X2) -> c_9(and^#(X1, X2))} The usable rules for this path are the following: { active(zeros()) -> mark(cons(0(), zeros())) , active(and(tt(), X)) -> mark(X) , active(length(nil())) -> mark(0()) , active(length(cons(N, L))) -> mark(s(length(L))) , active(cons(X1, X2)) -> cons(active(X1), X2) , active(and(X1, X2)) -> and(active(X1), X2) , active(length(X)) -> length(active(X)) , active(s(X)) -> s(active(X)) , length(mark(X)) -> mark(length(X)) , length(ok(X)) -> ok(length(X)) , cons(mark(X1), X2) -> mark(cons(X1, X2)) , and(mark(X1), X2) -> mark(and(X1, X2)) , s(mark(X)) -> mark(s(X)) , cons(ok(X1), ok(X2)) -> ok(cons(X1, X2)) , and(ok(X1), ok(X2)) -> ok(and(X1, X2)) , s(ok(X)) -> ok(s(X))} We have applied the subprocessor on the union of usable rules and weak (innermost) dependency pairs. 'Weight Gap Principle' ---------------------- Answer: YES(?,O(n^1)) Input Problem: innermost runtime-complexity with respect to Rules: { active(zeros()) -> mark(cons(0(), zeros())) , active(and(tt(), X)) -> mark(X) , active(length(nil())) -> mark(0()) , active(length(cons(N, L))) -> mark(s(length(L))) , active(cons(X1, X2)) -> cons(active(X1), X2) , active(and(X1, X2)) -> and(active(X1), X2) , active(length(X)) -> length(active(X)) , active(s(X)) -> s(active(X)) , length(mark(X)) -> mark(length(X)) , length(ok(X)) -> ok(length(X)) , cons(mark(X1), X2) -> mark(cons(X1, X2)) , and(mark(X1), X2) -> mark(and(X1, X2)) , s(mark(X)) -> mark(s(X)) , cons(ok(X1), ok(X2)) -> ok(cons(X1, X2)) , and(ok(X1), ok(X2)) -> ok(and(X1, X2)) , s(ok(X)) -> ok(s(X)) , active^#(and(X1, X2)) -> c_5(and^#(active(X1), X2)) , and^#(ok(X1), ok(X2)) -> c_21(and^#(X1, X2)) , and^#(mark(X1), X2) -> c_9(and^#(X1, X2))} Details: We apply the weight gap principle, strictly orienting the rules {and^#(mark(X1), X2) -> c_9(and^#(X1, X2))} and weakly orienting the rules {} using the following strongly linear interpretation: Processor 'Matrix Interpretation' oriented the following rules strictly: {and^#(mark(X1), X2) -> c_9(and^#(X1, X2))} Details: Interpretation Functions: active(x1) = [1] x1 + [1] zeros() = [0] mark(x1) = [1] x1 + [1] cons(x1, x2) = [1] x1 + [1] x2 + [0] 0() = [0] and(x1, x2) = [1] x1 + [1] x2 + [0] tt() = [0] length(x1) = [1] x1 + [0] nil() = [0] s(x1) = [1] x1 + [0] proper(x1) = [0] x1 + [0] ok(x1) = [1] x1 + [0] top(x1) = [0] x1 + [0] active^#(x1) = [1] x1 + [1] c_0(x1) = [0] x1 + [0] cons^#(x1, x2) = [0] x1 + [0] x2 + [0] c_1() = [0] c_2() = [0] c_3(x1) = [0] x1 + [0] s^#(x1) = [0] x1 + [0] c_4(x1) = [0] x1 + [0] c_5(x1) = [1] x1 + [0] and^#(x1, x2) = [1] x1 + [1] x2 + [0] c_6(x1) = [0] x1 + [0] length^#(x1) = [0] x1 + [0] c_7(x1) = [0] x1 + [0] c_8(x1) = [0] x1 + [0] c_9(x1) = [1] x1 + [0] c_10(x1) = [0] x1 + [0] c_11(x1) = [0] x1 + [0] proper^#(x1) = [0] x1 + [0] c_12() = [0] c_13(x1) = [0] x1 + [0] c_14() = [0] c_15(x1) = [0] x1 + [0] c_16() = [0] c_17(x1) = [0] x1 + [0] c_18() = [0] c_19(x1) = [0] x1 + [0] c_20(x1) = [0] x1 + [0] c_21(x1) = [1] x1 + [1] c_22(x1) = [0] x1 + [0] c_23(x1) = [0] x1 + [0] top^#(x1) = [0] x1 + [0] c_24(x1) = [0] x1 + [0] c_25(x1) = [0] x1 + [0] Finally we apply the subprocessor We apply the weight gap principle, strictly orienting the rules { cons(ok(X1), ok(X2)) -> ok(cons(X1, X2)) , and(ok(X1), ok(X2)) -> ok(and(X1, X2)) , and^#(ok(X1), ok(X2)) -> c_21(and^#(X1, X2))} and weakly orienting the rules {and^#(mark(X1), X2) -> c_9(and^#(X1, X2))} using the following strongly linear interpretation: Processor 'Matrix Interpretation' oriented the following rules strictly: { cons(ok(X1), ok(X2)) -> ok(cons(X1, X2)) , and(ok(X1), ok(X2)) -> ok(and(X1, X2)) , and^#(ok(X1), ok(X2)) -> c_21(and^#(X1, X2))} Details: Interpretation Functions: active(x1) = [1] x1 + [1] zeros() = [0] mark(x1) = [1] x1 + [1] cons(x1, x2) = [1] x1 + [1] x2 + [0] 0() = [0] and(x1, x2) = [1] x1 + [1] x2 + [0] tt() = [0] length(x1) = [1] x1 + [0] nil() = [0] s(x1) = [1] x1 + [0] proper(x1) = [0] x1 + [0] ok(x1) = [1] x1 + [8] top(x1) = [0] x1 + [0] active^#(x1) = [1] x1 + [1] c_0(x1) = [0] x1 + [0] cons^#(x1, x2) = [0] x1 + [0] x2 + [0] c_1() = [0] c_2() = [0] c_3(x1) = [0] x1 + [0] s^#(x1) = [0] x1 + [0] c_4(x1) = [0] x1 + [0] c_5(x1) = [1] x1 + [0] and^#(x1, x2) = [1] x1 + [1] x2 + [0] c_6(x1) = [0] x1 + [0] length^#(x1) = [0] x1 + [0] c_7(x1) = [0] x1 + [0] c_8(x1) = [0] x1 + [0] c_9(x1) = [1] x1 + [1] c_10(x1) = [0] x1 + [0] c_11(x1) = [0] x1 + [0] proper^#(x1) = [0] x1 + [0] c_12() = [0] c_13(x1) = [0] x1 + [0] c_14() = [0] c_15(x1) = [0] x1 + [0] c_16() = [0] c_17(x1) = [0] x1 + [0] c_18() = [0] c_19(x1) = [0] x1 + [0] c_20(x1) = [0] x1 + [0] c_21(x1) = [1] x1 + [1] c_22(x1) = [0] x1 + [0] c_23(x1) = [0] x1 + [0] top^#(x1) = [0] x1 + [0] c_24(x1) = [0] x1 + [0] c_25(x1) = [0] x1 + [0] Finally we apply the subprocessor We apply the weight gap principle, strictly orienting the rules {active^#(and(X1, X2)) -> c_5(and^#(active(X1), X2))} and weakly orienting the rules { cons(ok(X1), ok(X2)) -> ok(cons(X1, X2)) , and(ok(X1), ok(X2)) -> ok(and(X1, X2)) , and^#(ok(X1), ok(X2)) -> c_21(and^#(X1, X2)) , and^#(mark(X1), X2) -> c_9(and^#(X1, X2))} using the following strongly linear interpretation: Processor 'Matrix Interpretation' oriented the following rules strictly: {active^#(and(X1, X2)) -> c_5(and^#(active(X1), X2))} Details: Interpretation Functions: active(x1) = [1] x1 + [1] zeros() = [0] mark(x1) = [1] x1 + [1] cons(x1, x2) = [1] x1 + [1] x2 + [0] 0() = [0] and(x1, x2) = [1] x1 + [1] x2 + [0] tt() = [0] length(x1) = [1] x1 + [0] nil() = [0] s(x1) = [1] x1 + [0] proper(x1) = [0] x1 + [0] ok(x1) = [1] x1 + [0] top(x1) = [0] x1 + [0] active^#(x1) = [1] x1 + [3] c_0(x1) = [0] x1 + [0] cons^#(x1, x2) = [0] x1 + [0] x2 + [0] c_1() = [0] c_2() = [0] c_3(x1) = [0] x1 + [0] s^#(x1) = [0] x1 + [0] c_4(x1) = [0] x1 + [0] c_5(x1) = [1] x1 + [0] and^#(x1, x2) = [1] x1 + [1] x2 + [0] c_6(x1) = [0] x1 + [0] length^#(x1) = [0] x1 + [0] c_7(x1) = [0] x1 + [0] c_8(x1) = [0] x1 + [0] c_9(x1) = [1] x1 + [1] c_10(x1) = [0] x1 + [0] c_11(x1) = [0] x1 + [0] proper^#(x1) = [0] x1 + [0] c_12() = [0] c_13(x1) = [0] x1 + [0] c_14() = [0] c_15(x1) = [0] x1 + [0] c_16() = [0] c_17(x1) = [0] x1 + [0] c_18() = [0] c_19(x1) = [0] x1 + [0] c_20(x1) = [0] x1 + [0] c_21(x1) = [1] x1 + [0] c_22(x1) = [0] x1 + [0] c_23(x1) = [0] x1 + [0] top^#(x1) = [0] x1 + [0] c_24(x1) = [0] x1 + [0] c_25(x1) = [0] x1 + [0] Finally we apply the subprocessor We apply the weight gap principle, strictly orienting the rules {active(length(nil())) -> mark(0())} and weakly orienting the rules { active^#(and(X1, X2)) -> c_5(and^#(active(X1), X2)) , cons(ok(X1), ok(X2)) -> ok(cons(X1, X2)) , and(ok(X1), ok(X2)) -> ok(and(X1, X2)) , and^#(ok(X1), ok(X2)) -> c_21(and^#(X1, X2)) , and^#(mark(X1), X2) -> c_9(and^#(X1, X2))} using the following strongly linear interpretation: Processor 'Matrix Interpretation' oriented the following rules strictly: {active(length(nil())) -> mark(0())} Details: Interpretation Functions: active(x1) = [1] x1 + [1] zeros() = [0] mark(x1) = [1] x1 + [1] cons(x1, x2) = [1] x1 + [1] x2 + [0] 0() = [0] and(x1, x2) = [1] x1 + [1] x2 + [0] tt() = [0] length(x1) = [1] x1 + [0] nil() = [4] s(x1) = [1] x1 + [0] proper(x1) = [0] x1 + [0] ok(x1) = [1] x1 + [8] top(x1) = [0] x1 + [0] active^#(x1) = [1] x1 + [9] c_0(x1) = [0] x1 + [0] cons^#(x1, x2) = [0] x1 + [0] x2 + [0] c_1() = [0] c_2() = [0] c_3(x1) = [0] x1 + [0] s^#(x1) = [0] x1 + [0] c_4(x1) = [0] x1 + [0] c_5(x1) = [1] x1 + [8] and^#(x1, x2) = [1] x1 + [1] x2 + [0] c_6(x1) = [0] x1 + [0] length^#(x1) = [0] x1 + [0] c_7(x1) = [0] x1 + [0] c_8(x1) = [0] x1 + [0] c_9(x1) = [1] x1 + [1] c_10(x1) = [0] x1 + [0] c_11(x1) = [0] x1 + [0] proper^#(x1) = [0] x1 + [0] c_12() = [0] c_13(x1) = [0] x1 + [0] c_14() = [0] c_15(x1) = [0] x1 + [0] c_16() = [0] c_17(x1) = [0] x1 + [0] c_18() = [0] c_19(x1) = [0] x1 + [0] c_20(x1) = [0] x1 + [0] c_21(x1) = [1] x1 + [1] c_22(x1) = [0] x1 + [0] c_23(x1) = [0] x1 + [0] top^#(x1) = [0] x1 + [0] c_24(x1) = [0] x1 + [0] c_25(x1) = [0] x1 + [0] Finally we apply the subprocessor We apply the weight gap principle, strictly orienting the rules {active(and(tt(), X)) -> mark(X)} and weakly orienting the rules { active(length(nil())) -> mark(0()) , active^#(and(X1, X2)) -> c_5(and^#(active(X1), X2)) , cons(ok(X1), ok(X2)) -> ok(cons(X1, X2)) , and(ok(X1), ok(X2)) -> ok(and(X1, X2)) , and^#(ok(X1), ok(X2)) -> c_21(and^#(X1, X2)) , and^#(mark(X1), X2) -> c_9(and^#(X1, X2))} using the following strongly linear interpretation: Processor 'Matrix Interpretation' oriented the following rules strictly: {active(and(tt(), X)) -> mark(X)} Details: Interpretation Functions: active(x1) = [1] x1 + [1] zeros() = [0] mark(x1) = [1] x1 + [1] cons(x1, x2) = [1] x1 + [1] x2 + [0] 0() = [0] and(x1, x2) = [1] x1 + [1] x2 + [0] tt() = [8] length(x1) = [1] x1 + [0] nil() = [0] s(x1) = [1] x1 + [0] proper(x1) = [0] x1 + [0] ok(x1) = [1] x1 + [8] top(x1) = [0] x1 + [0] active^#(x1) = [1] x1 + [9] c_0(x1) = [0] x1 + [0] cons^#(x1, x2) = [0] x1 + [0] x2 + [0] c_1() = [0] c_2() = [0] c_3(x1) = [0] x1 + [0] s^#(x1) = [0] x1 + [0] c_4(x1) = [0] x1 + [0] c_5(x1) = [1] x1 + [2] and^#(x1, x2) = [1] x1 + [1] x2 + [2] c_6(x1) = [0] x1 + [0] length^#(x1) = [0] x1 + [0] c_7(x1) = [0] x1 + [0] c_8(x1) = [0] x1 + [0] c_9(x1) = [1] x1 + [1] c_10(x1) = [0] x1 + [0] c_11(x1) = [0] x1 + [0] proper^#(x1) = [0] x1 + [0] c_12() = [0] c_13(x1) = [0] x1 + [0] c_14() = [0] c_15(x1) = [0] x1 + [0] c_16() = [0] c_17(x1) = [0] x1 + [0] c_18() = [0] c_19(x1) = [0] x1 + [0] c_20(x1) = [0] x1 + [0] c_21(x1) = [1] x1 + [1] c_22(x1) = [0] x1 + [0] c_23(x1) = [0] x1 + [0] top^#(x1) = [0] x1 + [0] c_24(x1) = [0] x1 + [0] c_25(x1) = [0] x1 + [0] Finally we apply the subprocessor We apply the weight gap principle, strictly orienting the rules {active(length(cons(N, L))) -> mark(s(length(L)))} and weakly orienting the rules { active(and(tt(), X)) -> mark(X) , active(length(nil())) -> mark(0()) , active^#(and(X1, X2)) -> c_5(and^#(active(X1), X2)) , cons(ok(X1), ok(X2)) -> ok(cons(X1, X2)) , and(ok(X1), ok(X2)) -> ok(and(X1, X2)) , and^#(ok(X1), ok(X2)) -> c_21(and^#(X1, X2)) , and^#(mark(X1), X2) -> c_9(and^#(X1, X2))} using the following strongly linear interpretation: Processor 'Matrix Interpretation' oriented the following rules strictly: {active(length(cons(N, L))) -> mark(s(length(L)))} Details: Interpretation Functions: active(x1) = [1] x1 + [1] zeros() = [0] mark(x1) = [1] x1 + [2] cons(x1, x2) = [1] x1 + [1] x2 + [3] 0() = [0] and(x1, x2) = [1] x1 + [1] x2 + [0] tt() = [2] length(x1) = [1] x1 + [0] nil() = [1] s(x1) = [1] x1 + [0] proper(x1) = [0] x1 + [0] ok(x1) = [1] x1 + [8] top(x1) = [0] x1 + [0] active^#(x1) = [1] x1 + [1] c_0(x1) = [0] x1 + [0] cons^#(x1, x2) = [0] x1 + [0] x2 + [0] c_1() = [0] c_2() = [0] c_3(x1) = [0] x1 + [0] s^#(x1) = [0] x1 + [0] c_4(x1) = [0] x1 + [0] c_5(x1) = [1] x1 + [0] and^#(x1, x2) = [1] x1 + [1] x2 + [0] c_6(x1) = [0] x1 + [0] length^#(x1) = [0] x1 + [0] c_7(x1) = [0] x1 + [0] c_8(x1) = [0] x1 + [0] c_9(x1) = [1] x1 + [1] c_10(x1) = [0] x1 + [0] c_11(x1) = [0] x1 + [0] proper^#(x1) = [0] x1 + [0] c_12() = [0] c_13(x1) = [0] x1 + [0] c_14() = [0] c_15(x1) = [0] x1 + [0] c_16() = [0] c_17(x1) = [0] x1 + [0] c_18() = [0] c_19(x1) = [0] x1 + [0] c_20(x1) = [0] x1 + [0] c_21(x1) = [1] x1 + [5] c_22(x1) = [0] x1 + [0] c_23(x1) = [0] x1 + [0] top^#(x1) = [0] x1 + [0] c_24(x1) = [0] x1 + [0] c_25(x1) = [0] x1 + [0] Finally we apply the subprocessor We apply the weight gap principle, strictly orienting the rules {active(zeros()) -> mark(cons(0(), zeros()))} and weakly orienting the rules { active(length(cons(N, L))) -> mark(s(length(L))) , active(and(tt(), X)) -> mark(X) , active(length(nil())) -> mark(0()) , active^#(and(X1, X2)) -> c_5(and^#(active(X1), X2)) , cons(ok(X1), ok(X2)) -> ok(cons(X1, X2)) , and(ok(X1), ok(X2)) -> ok(and(X1, X2)) , and^#(ok(X1), ok(X2)) -> c_21(and^#(X1, X2)) , and^#(mark(X1), X2) -> c_9(and^#(X1, X2))} using the following strongly linear interpretation: Processor 'Matrix Interpretation' oriented the following rules strictly: {active(zeros()) -> mark(cons(0(), zeros()))} Details: Interpretation Functions: active(x1) = [1] x1 + [9] zeros() = [0] mark(x1) = [1] x1 + [6] cons(x1, x2) = [1] x1 + [1] x2 + [2] 0() = [0] and(x1, x2) = [1] x1 + [1] x2 + [1] tt() = [0] length(x1) = [1] x1 + [0] nil() = [11] s(x1) = [1] x1 + [2] proper(x1) = [0] x1 + [0] ok(x1) = [1] x1 + [0] top(x1) = [0] x1 + [0] active^#(x1) = [1] x1 + [15] c_0(x1) = [0] x1 + [0] cons^#(x1, x2) = [0] x1 + [0] x2 + [0] c_1() = [0] c_2() = [0] c_3(x1) = [0] x1 + [0] s^#(x1) = [0] x1 + [0] c_4(x1) = [0] x1 + [0] c_5(x1) = [1] x1 + [5] and^#(x1, x2) = [1] x1 + [1] x2 + [0] c_6(x1) = [0] x1 + [0] length^#(x1) = [0] x1 + [0] c_7(x1) = [0] x1 + [0] c_8(x1) = [0] x1 + [0] c_9(x1) = [1] x1 + [1] c_10(x1) = [0] x1 + [0] c_11(x1) = [0] x1 + [0] proper^#(x1) = [0] x1 + [0] c_12() = [0] c_13(x1) = [0] x1 + [0] c_14() = [0] c_15(x1) = [0] x1 + [0] c_16() = [0] c_17(x1) = [0] x1 + [0] c_18() = [0] c_19(x1) = [0] x1 + [0] c_20(x1) = [0] x1 + [0] c_21(x1) = [1] x1 + [0] c_22(x1) = [0] x1 + [0] c_23(x1) = [0] x1 + [0] top^#(x1) = [0] x1 + [0] c_24(x1) = [0] x1 + [0] c_25(x1) = [0] x1 + [0] Finally we apply the subprocessor 'fastest of 'combine', 'Bounds with default enrichment', 'Bounds with default enrichment'' ------------------------------------------------------------------------------------------ Answer: YES(?,O(n^1)) Input Problem: innermost relative runtime-complexity with respect to Strict Rules: { active(cons(X1, X2)) -> cons(active(X1), X2) , active(and(X1, X2)) -> and(active(X1), X2) , active(length(X)) -> length(active(X)) , active(s(X)) -> s(active(X)) , length(mark(X)) -> mark(length(X)) , length(ok(X)) -> ok(length(X)) , cons(mark(X1), X2) -> mark(cons(X1, X2)) , and(mark(X1), X2) -> mark(and(X1, X2)) , s(mark(X)) -> mark(s(X)) , s(ok(X)) -> ok(s(X))} Weak Rules: { active(zeros()) -> mark(cons(0(), zeros())) , active(length(cons(N, L))) -> mark(s(length(L))) , active(and(tt(), X)) -> mark(X) , active(length(nil())) -> mark(0()) , active^#(and(X1, X2)) -> c_5(and^#(active(X1), X2)) , cons(ok(X1), ok(X2)) -> ok(cons(X1, X2)) , and(ok(X1), ok(X2)) -> ok(and(X1, X2)) , and^#(ok(X1), ok(X2)) -> c_21(and^#(X1, X2)) , and^#(mark(X1), X2) -> c_9(and^#(X1, X2))} Details: The problem was solved by processor 'Bounds with default enrichment': 'Bounds with default enrichment' -------------------------------- Answer: YES(?,O(n^1)) Input Problem: innermost relative runtime-complexity with respect to Strict Rules: { active(cons(X1, X2)) -> cons(active(X1), X2) , active(and(X1, X2)) -> and(active(X1), X2) , active(length(X)) -> length(active(X)) , active(s(X)) -> s(active(X)) , length(mark(X)) -> mark(length(X)) , length(ok(X)) -> ok(length(X)) , cons(mark(X1), X2) -> mark(cons(X1, X2)) , and(mark(X1), X2) -> mark(and(X1, X2)) , s(mark(X)) -> mark(s(X)) , s(ok(X)) -> ok(s(X))} Weak Rules: { active(zeros()) -> mark(cons(0(), zeros())) , active(length(cons(N, L))) -> mark(s(length(L))) , active(and(tt(), X)) -> mark(X) , active(length(nil())) -> mark(0()) , active^#(and(X1, X2)) -> c_5(and^#(active(X1), X2)) , cons(ok(X1), ok(X2)) -> ok(cons(X1, X2)) , and(ok(X1), ok(X2)) -> ok(and(X1, X2)) , and^#(ok(X1), ok(X2)) -> c_21(and^#(X1, X2)) , and^#(mark(X1), X2) -> c_9(and^#(X1, X2))} Details: The problem is Match-bounded by 0. The enriched problem is compatible with the following automaton: { zeros_0() -> 2 , mark_0(2) -> 2 , 0_0() -> 2 , tt_0() -> 2 , nil_0() -> 2 , ok_0(2) -> 2 , active^#_0(2) -> 1 , and^#_0(2, 2) -> 1 , c_9_0(1) -> 1 , c_21_0(1) -> 1} 4) { active^#(length(X)) -> c_6(length^#(active(X))) , length^#(ok(X)) -> c_22(length^#(X)) , length^#(mark(X)) -> c_10(length^#(X))} The usable rules for this path are the following: { active(zeros()) -> mark(cons(0(), zeros())) , active(and(tt(), X)) -> mark(X) , active(length(nil())) -> mark(0()) , active(length(cons(N, L))) -> mark(s(length(L))) , active(cons(X1, X2)) -> cons(active(X1), X2) , active(and(X1, X2)) -> and(active(X1), X2) , active(length(X)) -> length(active(X)) , active(s(X)) -> s(active(X)) , length(mark(X)) -> mark(length(X)) , length(ok(X)) -> ok(length(X)) , cons(mark(X1), X2) -> mark(cons(X1, X2)) , and(mark(X1), X2) -> mark(and(X1, X2)) , s(mark(X)) -> mark(s(X)) , cons(ok(X1), ok(X2)) -> ok(cons(X1, X2)) , and(ok(X1), ok(X2)) -> ok(and(X1, X2)) , s(ok(X)) -> ok(s(X))} We have applied the subprocessor on the union of usable rules and weak (innermost) dependency pairs. 'Weight Gap Principle' ---------------------- Answer: YES(?,O(n^1)) Input Problem: innermost runtime-complexity with respect to Rules: { active(zeros()) -> mark(cons(0(), zeros())) , active(and(tt(), X)) -> mark(X) , active(length(nil())) -> mark(0()) , active(length(cons(N, L))) -> mark(s(length(L))) , active(cons(X1, X2)) -> cons(active(X1), X2) , active(and(X1, X2)) -> and(active(X1), X2) , active(length(X)) -> length(active(X)) , active(s(X)) -> s(active(X)) , length(mark(X)) -> mark(length(X)) , length(ok(X)) -> ok(length(X)) , cons(mark(X1), X2) -> mark(cons(X1, X2)) , and(mark(X1), X2) -> mark(and(X1, X2)) , s(mark(X)) -> mark(s(X)) , cons(ok(X1), ok(X2)) -> ok(cons(X1, X2)) , and(ok(X1), ok(X2)) -> ok(and(X1, X2)) , s(ok(X)) -> ok(s(X)) , active^#(length(X)) -> c_6(length^#(active(X))) , length^#(ok(X)) -> c_22(length^#(X)) , length^#(mark(X)) -> c_10(length^#(X))} Details: We apply the weight gap principle, strictly orienting the rules {length^#(mark(X)) -> c_10(length^#(X))} and weakly orienting the rules {} using the following strongly linear interpretation: Processor 'Matrix Interpretation' oriented the following rules strictly: {length^#(mark(X)) -> c_10(length^#(X))} Details: Interpretation Functions: active(x1) = [1] x1 + [1] zeros() = [0] mark(x1) = [1] x1 + [1] cons(x1, x2) = [1] x1 + [1] x2 + [0] 0() = [0] and(x1, x2) = [1] x1 + [1] x2 + [0] tt() = [0] length(x1) = [1] x1 + [0] nil() = [0] s(x1) = [1] x1 + [0] proper(x1) = [0] x1 + [0] ok(x1) = [1] x1 + [0] top(x1) = [0] x1 + [0] active^#(x1) = [1] x1 + [1] c_0(x1) = [0] x1 + [0] cons^#(x1, x2) = [0] x1 + [0] x2 + [0] c_1() = [0] c_2() = [0] c_3(x1) = [0] x1 + [0] s^#(x1) = [0] x1 + [0] c_4(x1) = [0] x1 + [0] c_5(x1) = [0] x1 + [0] and^#(x1, x2) = [0] x1 + [0] x2 + [0] c_6(x1) = [1] x1 + [0] length^#(x1) = [1] x1 + [0] c_7(x1) = [0] x1 + [0] c_8(x1) = [0] x1 + [0] c_9(x1) = [0] x1 + [0] c_10(x1) = [1] x1 + [0] c_11(x1) = [0] x1 + [0] proper^#(x1) = [0] x1 + [0] c_12() = [0] c_13(x1) = [0] x1 + [0] c_14() = [0] c_15(x1) = [0] x1 + [0] c_16() = [0] c_17(x1) = [0] x1 + [0] c_18() = [0] c_19(x1) = [0] x1 + [0] c_20(x1) = [0] x1 + [0] c_21(x1) = [0] x1 + [0] c_22(x1) = [1] x1 + [1] c_23(x1) = [0] x1 + [0] top^#(x1) = [0] x1 + [0] c_24(x1) = [0] x1 + [0] c_25(x1) = [0] x1 + [0] Finally we apply the subprocessor We apply the weight gap principle, strictly orienting the rules {active^#(length(X)) -> c_6(length^#(active(X)))} and weakly orienting the rules {length^#(mark(X)) -> c_10(length^#(X))} using the following strongly linear interpretation: Processor 'Matrix Interpretation' oriented the following rules strictly: {active^#(length(X)) -> c_6(length^#(active(X)))} Details: Interpretation Functions: active(x1) = [1] x1 + [1] zeros() = [0] mark(x1) = [1] x1 + [1] cons(x1, x2) = [1] x1 + [1] x2 + [0] 0() = [0] and(x1, x2) = [1] x1 + [1] x2 + [0] tt() = [0] length(x1) = [1] x1 + [0] nil() = [0] s(x1) = [1] x1 + [0] proper(x1) = [0] x1 + [0] ok(x1) = [1] x1 + [0] top(x1) = [0] x1 + [0] active^#(x1) = [1] x1 + [11] c_0(x1) = [0] x1 + [0] cons^#(x1, x2) = [0] x1 + [0] x2 + [0] c_1() = [0] c_2() = [0] c_3(x1) = [0] x1 + [0] s^#(x1) = [0] x1 + [0] c_4(x1) = [0] x1 + [0] c_5(x1) = [0] x1 + [0] and^#(x1, x2) = [0] x1 + [0] x2 + [0] c_6(x1) = [1] x1 + [7] length^#(x1) = [1] x1 + [1] c_7(x1) = [0] x1 + [0] c_8(x1) = [0] x1 + [0] c_9(x1) = [0] x1 + [0] c_10(x1) = [1] x1 + [0] c_11(x1) = [0] x1 + [0] proper^#(x1) = [0] x1 + [0] c_12() = [0] c_13(x1) = [0] x1 + [0] c_14() = [0] c_15(x1) = [0] x1 + [0] c_16() = [0] c_17(x1) = [0] x1 + [0] c_18() = [0] c_19(x1) = [0] x1 + [0] c_20(x1) = [0] x1 + [0] c_21(x1) = [0] x1 + [0] c_22(x1) = [1] x1 + [3] c_23(x1) = [0] x1 + [0] top^#(x1) = [0] x1 + [0] c_24(x1) = [0] x1 + [0] c_25(x1) = [0] x1 + [0] Finally we apply the subprocessor We apply the weight gap principle, strictly orienting the rules { cons(ok(X1), ok(X2)) -> ok(cons(X1, X2)) , and(ok(X1), ok(X2)) -> ok(and(X1, X2)) , length^#(ok(X)) -> c_22(length^#(X))} and weakly orienting the rules { active^#(length(X)) -> c_6(length^#(active(X))) , length^#(mark(X)) -> c_10(length^#(X))} using the following strongly linear interpretation: Processor 'Matrix Interpretation' oriented the following rules strictly: { cons(ok(X1), ok(X2)) -> ok(cons(X1, X2)) , and(ok(X1), ok(X2)) -> ok(and(X1, X2)) , length^#(ok(X)) -> c_22(length^#(X))} Details: Interpretation Functions: active(x1) = [1] x1 + [1] zeros() = [0] mark(x1) = [1] x1 + [1] cons(x1, x2) = [1] x1 + [1] x2 + [0] 0() = [0] and(x1, x2) = [1] x1 + [1] x2 + [0] tt() = [0] length(x1) = [1] x1 + [0] nil() = [0] s(x1) = [1] x1 + [0] proper(x1) = [0] x1 + [0] ok(x1) = [1] x1 + [4] top(x1) = [0] x1 + [0] active^#(x1) = [1] x1 + [5] c_0(x1) = [0] x1 + [0] cons^#(x1, x2) = [0] x1 + [0] x2 + [0] c_1() = [0] c_2() = [0] c_3(x1) = [0] x1 + [0] s^#(x1) = [0] x1 + [0] c_4(x1) = [0] x1 + [0] c_5(x1) = [0] x1 + [0] and^#(x1, x2) = [0] x1 + [0] x2 + [0] c_6(x1) = [1] x1 + [1] length^#(x1) = [1] x1 + [1] c_7(x1) = [0] x1 + [0] c_8(x1) = [0] x1 + [0] c_9(x1) = [0] x1 + [0] c_10(x1) = [1] x1 + [0] c_11(x1) = [0] x1 + [0] proper^#(x1) = [0] x1 + [0] c_12() = [0] c_13(x1) = [0] x1 + [0] c_14() = [0] c_15(x1) = [0] x1 + [0] c_16() = [0] c_17(x1) = [0] x1 + [0] c_18() = [0] c_19(x1) = [0] x1 + [0] c_20(x1) = [0] x1 + [0] c_21(x1) = [0] x1 + [0] c_22(x1) = [1] x1 + [0] c_23(x1) = [0] x1 + [0] top^#(x1) = [0] x1 + [0] c_24(x1) = [0] x1 + [0] c_25(x1) = [0] x1 + [0] Finally we apply the subprocessor We apply the weight gap principle, strictly orienting the rules {active(length(nil())) -> mark(0())} and weakly orienting the rules { cons(ok(X1), ok(X2)) -> ok(cons(X1, X2)) , and(ok(X1), ok(X2)) -> ok(and(X1, X2)) , length^#(ok(X)) -> c_22(length^#(X)) , active^#(length(X)) -> c_6(length^#(active(X))) , length^#(mark(X)) -> c_10(length^#(X))} using the following strongly linear interpretation: Processor 'Matrix Interpretation' oriented the following rules strictly: {active(length(nil())) -> mark(0())} Details: Interpretation Functions: active(x1) = [1] x1 + [1] zeros() = [0] mark(x1) = [1] x1 + [1] cons(x1, x2) = [1] x1 + [1] x2 + [0] 0() = [0] and(x1, x2) = [1] x1 + [1] x2 + [0] tt() = [0] length(x1) = [1] x1 + [0] nil() = [1] s(x1) = [1] x1 + [0] proper(x1) = [0] x1 + [0] ok(x1) = [1] x1 + [0] top(x1) = [0] x1 + [0] active^#(x1) = [1] x1 + [9] c_0(x1) = [0] x1 + [0] cons^#(x1, x2) = [0] x1 + [0] x2 + [0] c_1() = [0] c_2() = [0] c_3(x1) = [0] x1 + [0] s^#(x1) = [0] x1 + [0] c_4(x1) = [0] x1 + [0] c_5(x1) = [0] x1 + [0] and^#(x1, x2) = [0] x1 + [0] x2 + [0] c_6(x1) = [1] x1 + [1] length^#(x1) = [1] x1 + [0] c_7(x1) = [0] x1 + [0] c_8(x1) = [0] x1 + [0] c_9(x1) = [0] x1 + [0] c_10(x1) = [1] x1 + [0] c_11(x1) = [0] x1 + [0] proper^#(x1) = [0] x1 + [0] c_12() = [0] c_13(x1) = [0] x1 + [0] c_14() = [0] c_15(x1) = [0] x1 + [0] c_16() = [0] c_17(x1) = [0] x1 + [0] c_18() = [0] c_19(x1) = [0] x1 + [0] c_20(x1) = [0] x1 + [0] c_21(x1) = [0] x1 + [0] c_22(x1) = [1] x1 + [0] c_23(x1) = [0] x1 + [0] top^#(x1) = [0] x1 + [0] c_24(x1) = [0] x1 + [0] c_25(x1) = [0] x1 + [0] Finally we apply the subprocessor We apply the weight gap principle, strictly orienting the rules {active(and(tt(), X)) -> mark(X)} and weakly orienting the rules { active(length(nil())) -> mark(0()) , cons(ok(X1), ok(X2)) -> ok(cons(X1, X2)) , and(ok(X1), ok(X2)) -> ok(and(X1, X2)) , length^#(ok(X)) -> c_22(length^#(X)) , active^#(length(X)) -> c_6(length^#(active(X))) , length^#(mark(X)) -> c_10(length^#(X))} using the following strongly linear interpretation: Processor 'Matrix Interpretation' oriented the following rules strictly: {active(and(tt(), X)) -> mark(X)} Details: Interpretation Functions: active(x1) = [1] x1 + [1] zeros() = [0] mark(x1) = [1] x1 + [1] cons(x1, x2) = [1] x1 + [1] x2 + [0] 0() = [0] and(x1, x2) = [1] x1 + [1] x2 + [8] tt() = [0] length(x1) = [1] x1 + [0] nil() = [0] s(x1) = [1] x1 + [0] proper(x1) = [0] x1 + [0] ok(x1) = [1] x1 + [0] top(x1) = [0] x1 + [0] active^#(x1) = [1] x1 + [9] c_0(x1) = [0] x1 + [0] cons^#(x1, x2) = [0] x1 + [0] x2 + [0] c_1() = [0] c_2() = [0] c_3(x1) = [0] x1 + [0] s^#(x1) = [0] x1 + [0] c_4(x1) = [0] x1 + [0] c_5(x1) = [0] x1 + [0] and^#(x1, x2) = [0] x1 + [0] x2 + [0] c_6(x1) = [1] x1 + [1] length^#(x1) = [1] x1 + [7] c_7(x1) = [0] x1 + [0] c_8(x1) = [0] x1 + [0] c_9(x1) = [0] x1 + [0] c_10(x1) = [1] x1 + [0] c_11(x1) = [0] x1 + [0] proper^#(x1) = [0] x1 + [0] c_12() = [0] c_13(x1) = [0] x1 + [0] c_14() = [0] c_15(x1) = [0] x1 + [0] c_16() = [0] c_17(x1) = [0] x1 + [0] c_18() = [0] c_19(x1) = [0] x1 + [0] c_20(x1) = [0] x1 + [0] c_21(x1) = [0] x1 + [0] c_22(x1) = [1] x1 + [0] c_23(x1) = [0] x1 + [0] top^#(x1) = [0] x1 + [0] c_24(x1) = [0] x1 + [0] c_25(x1) = [0] x1 + [0] Finally we apply the subprocessor We apply the weight gap principle, strictly orienting the rules {active(length(cons(N, L))) -> mark(s(length(L)))} and weakly orienting the rules { active(and(tt(), X)) -> mark(X) , active(length(nil())) -> mark(0()) , cons(ok(X1), ok(X2)) -> ok(cons(X1, X2)) , and(ok(X1), ok(X2)) -> ok(and(X1, X2)) , length^#(ok(X)) -> c_22(length^#(X)) , active^#(length(X)) -> c_6(length^#(active(X))) , length^#(mark(X)) -> c_10(length^#(X))} using the following strongly linear interpretation: Processor 'Matrix Interpretation' oriented the following rules strictly: {active(length(cons(N, L))) -> mark(s(length(L)))} Details: Interpretation Functions: active(x1) = [1] x1 + [0] zeros() = [1] mark(x1) = [1] x1 + [2] cons(x1, x2) = [1] x1 + [1] x2 + [12] 0() = [1] and(x1, x2) = [1] x1 + [1] x2 + [0] tt() = [2] length(x1) = [1] x1 + [8] nil() = [8] s(x1) = [1] x1 + [0] proper(x1) = [0] x1 + [0] ok(x1) = [1] x1 + [0] top(x1) = [0] x1 + [0] active^#(x1) = [1] x1 + [8] c_0(x1) = [0] x1 + [0] cons^#(x1, x2) = [0] x1 + [0] x2 + [0] c_1() = [0] c_2() = [0] c_3(x1) = [0] x1 + [0] s^#(x1) = [0] x1 + [0] c_4(x1) = [0] x1 + [0] c_5(x1) = [0] x1 + [0] and^#(x1, x2) = [0] x1 + [0] x2 + [0] c_6(x1) = [1] x1 + [4] length^#(x1) = [1] x1 + [6] c_7(x1) = [0] x1 + [0] c_8(x1) = [0] x1 + [0] c_9(x1) = [0] x1 + [0] c_10(x1) = [1] x1 + [1] c_11(x1) = [0] x1 + [0] proper^#(x1) = [0] x1 + [0] c_12() = [0] c_13(x1) = [0] x1 + [0] c_14() = [0] c_15(x1) = [0] x1 + [0] c_16() = [0] c_17(x1) = [0] x1 + [0] c_18() = [0] c_19(x1) = [0] x1 + [0] c_20(x1) = [0] x1 + [0] c_21(x1) = [0] x1 + [0] c_22(x1) = [1] x1 + [0] c_23(x1) = [0] x1 + [0] top^#(x1) = [0] x1 + [0] c_24(x1) = [0] x1 + [0] c_25(x1) = [0] x1 + [0] Finally we apply the subprocessor We apply the weight gap principle, strictly orienting the rules {active(zeros()) -> mark(cons(0(), zeros()))} and weakly orienting the rules { active(length(cons(N, L))) -> mark(s(length(L))) , active(and(tt(), X)) -> mark(X) , active(length(nil())) -> mark(0()) , cons(ok(X1), ok(X2)) -> ok(cons(X1, X2)) , and(ok(X1), ok(X2)) -> ok(and(X1, X2)) , length^#(ok(X)) -> c_22(length^#(X)) , active^#(length(X)) -> c_6(length^#(active(X))) , length^#(mark(X)) -> c_10(length^#(X))} using the following strongly linear interpretation: Processor 'Matrix Interpretation' oriented the following rules strictly: {active(zeros()) -> mark(cons(0(), zeros()))} Details: Interpretation Functions: active(x1) = [1] x1 + [1] zeros() = [0] mark(x1) = [1] x1 + [0] cons(x1, x2) = [1] x1 + [1] x2 + [0] 0() = [0] and(x1, x2) = [1] x1 + [1] x2 + [8] tt() = [9] length(x1) = [1] x1 + [0] nil() = [4] s(x1) = [1] x1 + [0] proper(x1) = [0] x1 + [0] ok(x1) = [1] x1 + [0] top(x1) = [0] x1 + [0] active^#(x1) = [1] x1 + [9] c_0(x1) = [0] x1 + [0] cons^#(x1, x2) = [0] x1 + [0] x2 + [0] c_1() = [0] c_2() = [0] c_3(x1) = [0] x1 + [0] s^#(x1) = [0] x1 + [0] c_4(x1) = [0] x1 + [0] c_5(x1) = [0] x1 + [0] and^#(x1, x2) = [0] x1 + [0] x2 + [0] c_6(x1) = [1] x1 + [1] length^#(x1) = [1] x1 + [1] c_7(x1) = [0] x1 + [0] c_8(x1) = [0] x1 + [0] c_9(x1) = [0] x1 + [0] c_10(x1) = [1] x1 + [0] c_11(x1) = [0] x1 + [0] proper^#(x1) = [0] x1 + [0] c_12() = [0] c_13(x1) = [0] x1 + [0] c_14() = [0] c_15(x1) = [0] x1 + [0] c_16() = [0] c_17(x1) = [0] x1 + [0] c_18() = [0] c_19(x1) = [0] x1 + [0] c_20(x1) = [0] x1 + [0] c_21(x1) = [0] x1 + [0] c_22(x1) = [1] x1 + [0] c_23(x1) = [0] x1 + [0] top^#(x1) = [0] x1 + [0] c_24(x1) = [0] x1 + [0] c_25(x1) = [0] x1 + [0] Finally we apply the subprocessor 'fastest of 'combine', 'Bounds with default enrichment', 'Bounds with default enrichment'' ------------------------------------------------------------------------------------------ Answer: YES(?,O(n^1)) Input Problem: innermost relative runtime-complexity with respect to Strict Rules: { active(cons(X1, X2)) -> cons(active(X1), X2) , active(and(X1, X2)) -> and(active(X1), X2) , active(length(X)) -> length(active(X)) , active(s(X)) -> s(active(X)) , length(mark(X)) -> mark(length(X)) , length(ok(X)) -> ok(length(X)) , cons(mark(X1), X2) -> mark(cons(X1, X2)) , and(mark(X1), X2) -> mark(and(X1, X2)) , s(mark(X)) -> mark(s(X)) , s(ok(X)) -> ok(s(X))} Weak Rules: { active(zeros()) -> mark(cons(0(), zeros())) , active(length(cons(N, L))) -> mark(s(length(L))) , active(and(tt(), X)) -> mark(X) , active(length(nil())) -> mark(0()) , cons(ok(X1), ok(X2)) -> ok(cons(X1, X2)) , and(ok(X1), ok(X2)) -> ok(and(X1, X2)) , length^#(ok(X)) -> c_22(length^#(X)) , active^#(length(X)) -> c_6(length^#(active(X))) , length^#(mark(X)) -> c_10(length^#(X))} Details: The problem was solved by processor 'Bounds with default enrichment': 'Bounds with default enrichment' -------------------------------- Answer: YES(?,O(n^1)) Input Problem: innermost relative runtime-complexity with respect to Strict Rules: { active(cons(X1, X2)) -> cons(active(X1), X2) , active(and(X1, X2)) -> and(active(X1), X2) , active(length(X)) -> length(active(X)) , active(s(X)) -> s(active(X)) , length(mark(X)) -> mark(length(X)) , length(ok(X)) -> ok(length(X)) , cons(mark(X1), X2) -> mark(cons(X1, X2)) , and(mark(X1), X2) -> mark(and(X1, X2)) , s(mark(X)) -> mark(s(X)) , s(ok(X)) -> ok(s(X))} Weak Rules: { active(zeros()) -> mark(cons(0(), zeros())) , active(length(cons(N, L))) -> mark(s(length(L))) , active(and(tt(), X)) -> mark(X) , active(length(nil())) -> mark(0()) , cons(ok(X1), ok(X2)) -> ok(cons(X1, X2)) , and(ok(X1), ok(X2)) -> ok(and(X1, X2)) , length^#(ok(X)) -> c_22(length^#(X)) , active^#(length(X)) -> c_6(length^#(active(X))) , length^#(mark(X)) -> c_10(length^#(X))} Details: The problem is Match-bounded by 0. The enriched problem is compatible with the following automaton: { zeros_0() -> 2 , mark_0(2) -> 3 , mark_0(3) -> 3 , mark_0(5) -> 3 , mark_0(7) -> 3 , mark_0(9) -> 3 , mark_0(12) -> 3 , 0_0() -> 5 , tt_0() -> 7 , nil_0() -> 9 , ok_0(2) -> 12 , ok_0(3) -> 12 , ok_0(5) -> 12 , ok_0(7) -> 12 , ok_0(9) -> 12 , ok_0(12) -> 12 , active^#_0(2) -> 14 , active^#_0(3) -> 14 , active^#_0(5) -> 14 , active^#_0(7) -> 14 , active^#_0(9) -> 14 , active^#_0(12) -> 14 , length^#_0(2) -> 25 , length^#_0(3) -> 25 , length^#_0(5) -> 25 , length^#_0(7) -> 25 , length^#_0(9) -> 25 , length^#_0(12) -> 25 , c_10_0(25) -> 25 , c_22_0(25) -> 25} 5) { active^#(s(X)) -> c_7(s^#(active(X))) , s^#(ok(X)) -> c_23(s^#(X)) , s^#(mark(X)) -> c_11(s^#(X))} The usable rules for this path are the following: { active(zeros()) -> mark(cons(0(), zeros())) , active(and(tt(), X)) -> mark(X) , active(length(nil())) -> mark(0()) , active(length(cons(N, L))) -> mark(s(length(L))) , active(cons(X1, X2)) -> cons(active(X1), X2) , active(and(X1, X2)) -> and(active(X1), X2) , active(length(X)) -> length(active(X)) , active(s(X)) -> s(active(X)) , length(mark(X)) -> mark(length(X)) , length(ok(X)) -> ok(length(X)) , cons(mark(X1), X2) -> mark(cons(X1, X2)) , and(mark(X1), X2) -> mark(and(X1, X2)) , s(mark(X)) -> mark(s(X)) , cons(ok(X1), ok(X2)) -> ok(cons(X1, X2)) , and(ok(X1), ok(X2)) -> ok(and(X1, X2)) , s(ok(X)) -> ok(s(X))} We have applied the subprocessor on the union of usable rules and weak (innermost) dependency pairs. 'Weight Gap Principle' ---------------------- Answer: YES(?,O(n^1)) Input Problem: innermost runtime-complexity with respect to Rules: { active(zeros()) -> mark(cons(0(), zeros())) , active(and(tt(), X)) -> mark(X) , active(length(nil())) -> mark(0()) , active(length(cons(N, L))) -> mark(s(length(L))) , active(cons(X1, X2)) -> cons(active(X1), X2) , active(and(X1, X2)) -> and(active(X1), X2) , active(length(X)) -> length(active(X)) , active(s(X)) -> s(active(X)) , length(mark(X)) -> mark(length(X)) , length(ok(X)) -> ok(length(X)) , cons(mark(X1), X2) -> mark(cons(X1, X2)) , and(mark(X1), X2) -> mark(and(X1, X2)) , s(mark(X)) -> mark(s(X)) , cons(ok(X1), ok(X2)) -> ok(cons(X1, X2)) , and(ok(X1), ok(X2)) -> ok(and(X1, X2)) , s(ok(X)) -> ok(s(X)) , active^#(s(X)) -> c_7(s^#(active(X))) , s^#(ok(X)) -> c_23(s^#(X)) , s^#(mark(X)) -> c_11(s^#(X))} Details: We apply the weight gap principle, strictly orienting the rules { cons(ok(X1), ok(X2)) -> ok(cons(X1, X2)) , and(ok(X1), ok(X2)) -> ok(and(X1, X2)) , s^#(ok(X)) -> c_23(s^#(X))} and weakly orienting the rules {} using the following strongly linear interpretation: Processor 'Matrix Interpretation' oriented the following rules strictly: { cons(ok(X1), ok(X2)) -> ok(cons(X1, X2)) , and(ok(X1), ok(X2)) -> ok(and(X1, X2)) , s^#(ok(X)) -> c_23(s^#(X))} Details: Interpretation Functions: active(x1) = [1] x1 + [1] zeros() = [0] mark(x1) = [1] x1 + [1] cons(x1, x2) = [1] x1 + [1] x2 + [0] 0() = [0] and(x1, x2) = [1] x1 + [1] x2 + [0] tt() = [0] length(x1) = [1] x1 + [0] nil() = [0] s(x1) = [1] x1 + [0] proper(x1) = [0] x1 + [0] ok(x1) = [1] x1 + [2] top(x1) = [0] x1 + [0] active^#(x1) = [1] x1 + [1] c_0(x1) = [0] x1 + [0] cons^#(x1, x2) = [0] x1 + [0] x2 + [0] c_1() = [0] c_2() = [0] c_3(x1) = [0] x1 + [0] s^#(x1) = [1] x1 + [0] c_4(x1) = [0] x1 + [0] c_5(x1) = [0] x1 + [0] and^#(x1, x2) = [0] x1 + [0] x2 + [0] c_6(x1) = [0] x1 + [0] length^#(x1) = [0] x1 + [0] c_7(x1) = [1] x1 + [0] c_8(x1) = [0] x1 + [0] c_9(x1) = [0] x1 + [0] c_10(x1) = [0] x1 + [0] c_11(x1) = [1] x1 + [1] proper^#(x1) = [0] x1 + [0] c_12() = [0] c_13(x1) = [0] x1 + [0] c_14() = [0] c_15(x1) = [0] x1 + [0] c_16() = [0] c_17(x1) = [0] x1 + [0] c_18() = [0] c_19(x1) = [0] x1 + [0] c_20(x1) = [0] x1 + [0] c_21(x1) = [0] x1 + [0] c_22(x1) = [0] x1 + [0] c_23(x1) = [1] x1 + [1] top^#(x1) = [0] x1 + [0] c_24(x1) = [0] x1 + [0] c_25(x1) = [0] x1 + [0] Finally we apply the subprocessor We apply the weight gap principle, strictly orienting the rules { active^#(s(X)) -> c_7(s^#(active(X))) , s^#(mark(X)) -> c_11(s^#(X))} and weakly orienting the rules { cons(ok(X1), ok(X2)) -> ok(cons(X1, X2)) , and(ok(X1), ok(X2)) -> ok(and(X1, X2)) , s^#(ok(X)) -> c_23(s^#(X))} using the following strongly linear interpretation: Processor 'Matrix Interpretation' oriented the following rules strictly: { active^#(s(X)) -> c_7(s^#(active(X))) , s^#(mark(X)) -> c_11(s^#(X))} Details: Interpretation Functions: active(x1) = [1] x1 + [1] zeros() = [0] mark(x1) = [1] x1 + [1] cons(x1, x2) = [1] x1 + [1] x2 + [0] 0() = [0] and(x1, x2) = [1] x1 + [1] x2 + [0] tt() = [0] length(x1) = [1] x1 + [0] nil() = [0] s(x1) = [1] x1 + [1] proper(x1) = [0] x1 + [0] ok(x1) = [1] x1 + [0] top(x1) = [0] x1 + [0] active^#(x1) = [1] x1 + [11] c_0(x1) = [0] x1 + [0] cons^#(x1, x2) = [0] x1 + [0] x2 + [0] c_1() = [0] c_2() = [0] c_3(x1) = [0] x1 + [0] s^#(x1) = [1] x1 + [3] c_4(x1) = [0] x1 + [0] c_5(x1) = [0] x1 + [0] and^#(x1, x2) = [0] x1 + [0] x2 + [0] c_6(x1) = [0] x1 + [0] length^#(x1) = [0] x1 + [0] c_7(x1) = [1] x1 + [1] c_8(x1) = [0] x1 + [0] c_9(x1) = [0] x1 + [0] c_10(x1) = [0] x1 + [0] c_11(x1) = [1] x1 + [0] proper^#(x1) = [0] x1 + [0] c_12() = [0] c_13(x1) = [0] x1 + [0] c_14() = [0] c_15(x1) = [0] x1 + [0] c_16() = [0] c_17(x1) = [0] x1 + [0] c_18() = [0] c_19(x1) = [0] x1 + [0] c_20(x1) = [0] x1 + [0] c_21(x1) = [0] x1 + [0] c_22(x1) = [0] x1 + [0] c_23(x1) = [1] x1 + [0] top^#(x1) = [0] x1 + [0] c_24(x1) = [0] x1 + [0] c_25(x1) = [0] x1 + [0] Finally we apply the subprocessor We apply the weight gap principle, strictly orienting the rules {active(length(nil())) -> mark(0())} and weakly orienting the rules { active^#(s(X)) -> c_7(s^#(active(X))) , s^#(mark(X)) -> c_11(s^#(X)) , cons(ok(X1), ok(X2)) -> ok(cons(X1, X2)) , and(ok(X1), ok(X2)) -> ok(and(X1, X2)) , s^#(ok(X)) -> c_23(s^#(X))} using the following strongly linear interpretation: Processor 'Matrix Interpretation' oriented the following rules strictly: {active(length(nil())) -> mark(0())} Details: Interpretation Functions: active(x1) = [1] x1 + [1] zeros() = [0] mark(x1) = [1] x1 + [1] cons(x1, x2) = [1] x1 + [1] x2 + [0] 0() = [0] and(x1, x2) = [1] x1 + [1] x2 + [0] tt() = [0] length(x1) = [1] x1 + [0] nil() = [8] s(x1) = [1] x1 + [0] proper(x1) = [0] x1 + [0] ok(x1) = [1] x1 + [0] top(x1) = [0] x1 + [0] active^#(x1) = [1] x1 + [9] c_0(x1) = [0] x1 + [0] cons^#(x1, x2) = [0] x1 + [0] x2 + [0] c_1() = [0] c_2() = [0] c_3(x1) = [0] x1 + [0] s^#(x1) = [1] x1 + [3] c_4(x1) = [0] x1 + [0] c_5(x1) = [0] x1 + [0] and^#(x1, x2) = [0] x1 + [0] x2 + [0] c_6(x1) = [0] x1 + [0] length^#(x1) = [0] x1 + [0] c_7(x1) = [1] x1 + [1] c_8(x1) = [0] x1 + [0] c_9(x1) = [0] x1 + [0] c_10(x1) = [0] x1 + [0] c_11(x1) = [1] x1 + [0] proper^#(x1) = [0] x1 + [0] c_12() = [0] c_13(x1) = [0] x1 + [0] c_14() = [0] c_15(x1) = [0] x1 + [0] c_16() = [0] c_17(x1) = [0] x1 + [0] c_18() = [0] c_19(x1) = [0] x1 + [0] c_20(x1) = [0] x1 + [0] c_21(x1) = [0] x1 + [0] c_22(x1) = [0] x1 + [0] c_23(x1) = [1] x1 + [0] top^#(x1) = [0] x1 + [0] c_24(x1) = [0] x1 + [0] c_25(x1) = [0] x1 + [0] Finally we apply the subprocessor We apply the weight gap principle, strictly orienting the rules {active(and(tt(), X)) -> mark(X)} and weakly orienting the rules { active(length(nil())) -> mark(0()) , active^#(s(X)) -> c_7(s^#(active(X))) , s^#(mark(X)) -> c_11(s^#(X)) , cons(ok(X1), ok(X2)) -> ok(cons(X1, X2)) , and(ok(X1), ok(X2)) -> ok(and(X1, X2)) , s^#(ok(X)) -> c_23(s^#(X))} using the following strongly linear interpretation: Processor 'Matrix Interpretation' oriented the following rules strictly: {active(and(tt(), X)) -> mark(X)} Details: Interpretation Functions: active(x1) = [1] x1 + [1] zeros() = [0] mark(x1) = [1] x1 + [1] cons(x1, x2) = [1] x1 + [1] x2 + [0] 0() = [0] and(x1, x2) = [1] x1 + [1] x2 + [0] tt() = [8] length(x1) = [1] x1 + [0] nil() = [0] s(x1) = [1] x1 + [0] proper(x1) = [0] x1 + [0] ok(x1) = [1] x1 + [0] top(x1) = [0] x1 + [0] active^#(x1) = [1] x1 + [9] c_0(x1) = [0] x1 + [0] cons^#(x1, x2) = [0] x1 + [0] x2 + [0] c_1() = [0] c_2() = [0] c_3(x1) = [0] x1 + [0] s^#(x1) = [1] x1 + [1] c_4(x1) = [0] x1 + [0] c_5(x1) = [0] x1 + [0] and^#(x1, x2) = [0] x1 + [0] x2 + [0] c_6(x1) = [0] x1 + [0] length^#(x1) = [0] x1 + [0] c_7(x1) = [1] x1 + [1] c_8(x1) = [0] x1 + [0] c_9(x1) = [0] x1 + [0] c_10(x1) = [0] x1 + [0] c_11(x1) = [1] x1 + [0] proper^#(x1) = [0] x1 + [0] c_12() = [0] c_13(x1) = [0] x1 + [0] c_14() = [0] c_15(x1) = [0] x1 + [0] c_16() = [0] c_17(x1) = [0] x1 + [0] c_18() = [0] c_19(x1) = [0] x1 + [0] c_20(x1) = [0] x1 + [0] c_21(x1) = [0] x1 + [0] c_22(x1) = [0] x1 + [0] c_23(x1) = [1] x1 + [0] top^#(x1) = [0] x1 + [0] c_24(x1) = [0] x1 + [0] c_25(x1) = [0] x1 + [0] Finally we apply the subprocessor We apply the weight gap principle, strictly orienting the rules {active(length(cons(N, L))) -> mark(s(length(L)))} and weakly orienting the rules { active(and(tt(), X)) -> mark(X) , active(length(nil())) -> mark(0()) , active^#(s(X)) -> c_7(s^#(active(X))) , s^#(mark(X)) -> c_11(s^#(X)) , cons(ok(X1), ok(X2)) -> ok(cons(X1, X2)) , and(ok(X1), ok(X2)) -> ok(and(X1, X2)) , s^#(ok(X)) -> c_23(s^#(X))} using the following strongly linear interpretation: Processor 'Matrix Interpretation' oriented the following rules strictly: {active(length(cons(N, L))) -> mark(s(length(L)))} Details: Interpretation Functions: active(x1) = [1] x1 + [0] zeros() = [0] mark(x1) = [1] x1 + [0] cons(x1, x2) = [1] x1 + [1] x2 + [1] 0() = [8] and(x1, x2) = [1] x1 + [1] x2 + [0] tt() = [5] length(x1) = [1] x1 + [3] nil() = [10] s(x1) = [1] x1 + [0] proper(x1) = [0] x1 + [0] ok(x1) = [1] x1 + [8] top(x1) = [0] x1 + [0] active^#(x1) = [1] x1 + [4] c_0(x1) = [0] x1 + [0] cons^#(x1, x2) = [0] x1 + [0] x2 + [0] c_1() = [0] c_2() = [0] c_3(x1) = [0] x1 + [0] s^#(x1) = [1] x1 + [0] c_4(x1) = [0] x1 + [0] c_5(x1) = [0] x1 + [0] and^#(x1, x2) = [0] x1 + [0] x2 + [0] c_6(x1) = [0] x1 + [0] length^#(x1) = [0] x1 + [0] c_7(x1) = [1] x1 + [0] c_8(x1) = [0] x1 + [0] c_9(x1) = [0] x1 + [0] c_10(x1) = [0] x1 + [0] c_11(x1) = [1] x1 + [0] proper^#(x1) = [0] x1 + [0] c_12() = [0] c_13(x1) = [0] x1 + [0] c_14() = [0] c_15(x1) = [0] x1 + [0] c_16() = [0] c_17(x1) = [0] x1 + [0] c_18() = [0] c_19(x1) = [0] x1 + [0] c_20(x1) = [0] x1 + [0] c_21(x1) = [0] x1 + [0] c_22(x1) = [0] x1 + [0] c_23(x1) = [1] x1 + [1] top^#(x1) = [0] x1 + [0] c_24(x1) = [0] x1 + [0] c_25(x1) = [0] x1 + [0] Finally we apply the subprocessor We apply the weight gap principle, strictly orienting the rules {active(zeros()) -> mark(cons(0(), zeros()))} and weakly orienting the rules { active(length(cons(N, L))) -> mark(s(length(L))) , active(and(tt(), X)) -> mark(X) , active(length(nil())) -> mark(0()) , active^#(s(X)) -> c_7(s^#(active(X))) , s^#(mark(X)) -> c_11(s^#(X)) , cons(ok(X1), ok(X2)) -> ok(cons(X1, X2)) , and(ok(X1), ok(X2)) -> ok(and(X1, X2)) , s^#(ok(X)) -> c_23(s^#(X))} using the following strongly linear interpretation: Processor 'Matrix Interpretation' oriented the following rules strictly: {active(zeros()) -> mark(cons(0(), zeros()))} Details: Interpretation Functions: active(x1) = [1] x1 + [1] zeros() = [0] mark(x1) = [1] x1 + [0] cons(x1, x2) = [1] x1 + [1] x2 + [0] 0() = [0] and(x1, x2) = [1] x1 + [1] x2 + [0] tt() = [3] length(x1) = [1] x1 + [0] nil() = [0] s(x1) = [1] x1 + [0] proper(x1) = [0] x1 + [0] ok(x1) = [1] x1 + [0] top(x1) = [0] x1 + [0] active^#(x1) = [1] x1 + [9] c_0(x1) = [0] x1 + [0] cons^#(x1, x2) = [0] x1 + [0] x2 + [0] c_1() = [0] c_2() = [0] c_3(x1) = [0] x1 + [0] s^#(x1) = [1] x1 + [1] c_4(x1) = [0] x1 + [0] c_5(x1) = [0] x1 + [0] and^#(x1, x2) = [0] x1 + [0] x2 + [0] c_6(x1) = [0] x1 + [0] length^#(x1) = [0] x1 + [0] c_7(x1) = [1] x1 + [5] c_8(x1) = [0] x1 + [0] c_9(x1) = [0] x1 + [0] c_10(x1) = [0] x1 + [0] c_11(x1) = [1] x1 + [0] proper^#(x1) = [0] x1 + [0] c_12() = [0] c_13(x1) = [0] x1 + [0] c_14() = [0] c_15(x1) = [0] x1 + [0] c_16() = [0] c_17(x1) = [0] x1 + [0] c_18() = [0] c_19(x1) = [0] x1 + [0] c_20(x1) = [0] x1 + [0] c_21(x1) = [0] x1 + [0] c_22(x1) = [0] x1 + [0] c_23(x1) = [1] x1 + [0] top^#(x1) = [0] x1 + [0] c_24(x1) = [0] x1 + [0] c_25(x1) = [0] x1 + [0] Finally we apply the subprocessor 'fastest of 'combine', 'Bounds with default enrichment', 'Bounds with default enrichment'' ------------------------------------------------------------------------------------------ Answer: YES(?,O(n^1)) Input Problem: innermost relative runtime-complexity with respect to Strict Rules: { active(cons(X1, X2)) -> cons(active(X1), X2) , active(and(X1, X2)) -> and(active(X1), X2) , active(length(X)) -> length(active(X)) , active(s(X)) -> s(active(X)) , length(mark(X)) -> mark(length(X)) , length(ok(X)) -> ok(length(X)) , cons(mark(X1), X2) -> mark(cons(X1, X2)) , and(mark(X1), X2) -> mark(and(X1, X2)) , s(mark(X)) -> mark(s(X)) , s(ok(X)) -> ok(s(X))} Weak Rules: { active(zeros()) -> mark(cons(0(), zeros())) , active(length(cons(N, L))) -> mark(s(length(L))) , active(and(tt(), X)) -> mark(X) , active(length(nil())) -> mark(0()) , active^#(s(X)) -> c_7(s^#(active(X))) , s^#(mark(X)) -> c_11(s^#(X)) , cons(ok(X1), ok(X2)) -> ok(cons(X1, X2)) , and(ok(X1), ok(X2)) -> ok(and(X1, X2)) , s^#(ok(X)) -> c_23(s^#(X))} Details: The problem was solved by processor 'Bounds with default enrichment': 'Bounds with default enrichment' -------------------------------- Answer: YES(?,O(n^1)) Input Problem: innermost relative runtime-complexity with respect to Strict Rules: { active(cons(X1, X2)) -> cons(active(X1), X2) , active(and(X1, X2)) -> and(active(X1), X2) , active(length(X)) -> length(active(X)) , active(s(X)) -> s(active(X)) , length(mark(X)) -> mark(length(X)) , length(ok(X)) -> ok(length(X)) , cons(mark(X1), X2) -> mark(cons(X1, X2)) , and(mark(X1), X2) -> mark(and(X1, X2)) , s(mark(X)) -> mark(s(X)) , s(ok(X)) -> ok(s(X))} Weak Rules: { active(zeros()) -> mark(cons(0(), zeros())) , active(length(cons(N, L))) -> mark(s(length(L))) , active(and(tt(), X)) -> mark(X) , active(length(nil())) -> mark(0()) , active^#(s(X)) -> c_7(s^#(active(X))) , s^#(mark(X)) -> c_11(s^#(X)) , cons(ok(X1), ok(X2)) -> ok(cons(X1, X2)) , and(ok(X1), ok(X2)) -> ok(and(X1, X2)) , s^#(ok(X)) -> c_23(s^#(X))} Details: The problem is Match-bounded by 0. The enriched problem is compatible with the following automaton: { zeros_0() -> 2 , mark_0(2) -> 3 , mark_0(3) -> 3 , mark_0(5) -> 3 , mark_0(7) -> 3 , mark_0(9) -> 3 , mark_0(12) -> 3 , 0_0() -> 5 , tt_0() -> 7 , nil_0() -> 9 , ok_0(2) -> 12 , ok_0(3) -> 12 , ok_0(5) -> 12 , ok_0(7) -> 12 , ok_0(9) -> 12 , ok_0(12) -> 12 , active^#_0(2) -> 14 , active^#_0(3) -> 14 , active^#_0(5) -> 14 , active^#_0(7) -> 14 , active^#_0(9) -> 14 , active^#_0(12) -> 14 , s^#_0(2) -> 20 , s^#_0(3) -> 20 , s^#_0(5) -> 20 , s^#_0(7) -> 20 , s^#_0(9) -> 20 , s^#_0(12) -> 20 , c_11_0(20) -> 20 , c_23_0(20) -> 20} 6) { proper^#(cons(X1, X2)) -> c_13(cons^#(proper(X1), proper(X2))) , cons^#(ok(X1), ok(X2)) -> c_20(cons^#(X1, X2)) , cons^#(mark(X1), X2) -> c_8(cons^#(X1, X2))} The usable rules for this path are the following: { proper(zeros()) -> ok(zeros()) , proper(cons(X1, X2)) -> cons(proper(X1), proper(X2)) , proper(0()) -> ok(0()) , proper(and(X1, X2)) -> and(proper(X1), proper(X2)) , proper(tt()) -> ok(tt()) , proper(length(X)) -> length(proper(X)) , proper(nil()) -> ok(nil()) , proper(s(X)) -> s(proper(X)) , length(mark(X)) -> mark(length(X)) , length(ok(X)) -> ok(length(X)) , cons(mark(X1), X2) -> mark(cons(X1, X2)) , and(mark(X1), X2) -> mark(and(X1, X2)) , s(mark(X)) -> mark(s(X)) , cons(ok(X1), ok(X2)) -> ok(cons(X1, X2)) , and(ok(X1), ok(X2)) -> ok(and(X1, X2)) , s(ok(X)) -> ok(s(X))} We have applied the subprocessor on the union of usable rules and weak (innermost) dependency pairs. 'Weight Gap Principle' ---------------------- Answer: YES(?,O(n^1)) Input Problem: innermost runtime-complexity with respect to Rules: { proper(zeros()) -> ok(zeros()) , proper(cons(X1, X2)) -> cons(proper(X1), proper(X2)) , proper(0()) -> ok(0()) , proper(and(X1, X2)) -> and(proper(X1), proper(X2)) , proper(tt()) -> ok(tt()) , proper(length(X)) -> length(proper(X)) , proper(nil()) -> ok(nil()) , proper(s(X)) -> s(proper(X)) , length(mark(X)) -> mark(length(X)) , length(ok(X)) -> ok(length(X)) , cons(mark(X1), X2) -> mark(cons(X1, X2)) , and(mark(X1), X2) -> mark(and(X1, X2)) , s(mark(X)) -> mark(s(X)) , cons(ok(X1), ok(X2)) -> ok(cons(X1, X2)) , and(ok(X1), ok(X2)) -> ok(and(X1, X2)) , s(ok(X)) -> ok(s(X)) , proper^#(cons(X1, X2)) -> c_13(cons^#(proper(X1), proper(X2))) , cons^#(ok(X1), ok(X2)) -> c_20(cons^#(X1, X2)) , cons^#(mark(X1), X2) -> c_8(cons^#(X1, X2))} Details: We apply the weight gap principle, strictly orienting the rules { cons(ok(X1), ok(X2)) -> ok(cons(X1, X2)) , and(ok(X1), ok(X2)) -> ok(and(X1, X2)) , cons^#(ok(X1), ok(X2)) -> c_20(cons^#(X1, X2))} and weakly orienting the rules {} using the following strongly linear interpretation: Processor 'Matrix Interpretation' oriented the following rules strictly: { cons(ok(X1), ok(X2)) -> ok(cons(X1, X2)) , and(ok(X1), ok(X2)) -> ok(and(X1, X2)) , cons^#(ok(X1), ok(X2)) -> c_20(cons^#(X1, X2))} Details: Interpretation Functions: active(x1) = [0] x1 + [0] zeros() = [0] mark(x1) = [1] x1 + [0] cons(x1, x2) = [1] x1 + [1] x2 + [0] 0() = [0] and(x1, x2) = [1] x1 + [1] x2 + [0] tt() = [0] length(x1) = [1] x1 + [0] nil() = [0] s(x1) = [1] x1 + [1] proper(x1) = [1] x1 + [1] ok(x1) = [1] x1 + [1] top(x1) = [0] x1 + [0] active^#(x1) = [0] x1 + [0] c_0(x1) = [0] x1 + [0] cons^#(x1, x2) = [1] x1 + [1] x2 + [0] c_1() = [0] c_2() = [0] c_3(x1) = [0] x1 + [0] s^#(x1) = [0] x1 + [0] c_4(x1) = [0] x1 + [0] c_5(x1) = [0] x1 + [0] and^#(x1, x2) = [0] x1 + [0] x2 + [0] c_6(x1) = [0] x1 + [0] length^#(x1) = [0] x1 + [0] c_7(x1) = [0] x1 + [0] c_8(x1) = [1] x1 + [1] c_9(x1) = [0] x1 + [0] c_10(x1) = [0] x1 + [0] c_11(x1) = [0] x1 + [0] proper^#(x1) = [1] x1 + [1] c_12() = [0] c_13(x1) = [1] x1 + [1] c_14() = [0] c_15(x1) = [0] x1 + [0] c_16() = [0] c_17(x1) = [0] x1 + [0] c_18() = [0] c_19(x1) = [0] x1 + [0] c_20(x1) = [1] x1 + [1] c_21(x1) = [0] x1 + [0] c_22(x1) = [0] x1 + [0] c_23(x1) = [0] x1 + [0] top^#(x1) = [0] x1 + [0] c_24(x1) = [0] x1 + [0] c_25(x1) = [0] x1 + [0] Finally we apply the subprocessor We apply the weight gap principle, strictly orienting the rules {cons^#(mark(X1), X2) -> c_8(cons^#(X1, X2))} and weakly orienting the rules { cons(ok(X1), ok(X2)) -> ok(cons(X1, X2)) , and(ok(X1), ok(X2)) -> ok(and(X1, X2)) , cons^#(ok(X1), ok(X2)) -> c_20(cons^#(X1, X2))} using the following strongly linear interpretation: Processor 'Matrix Interpretation' oriented the following rules strictly: {cons^#(mark(X1), X2) -> c_8(cons^#(X1, X2))} Details: Interpretation Functions: active(x1) = [0] x1 + [0] zeros() = [0] mark(x1) = [1] x1 + [2] cons(x1, x2) = [1] x1 + [1] x2 + [0] 0() = [0] and(x1, x2) = [1] x1 + [1] x2 + [0] tt() = [0] length(x1) = [1] x1 + [2] nil() = [0] s(x1) = [1] x1 + [0] proper(x1) = [1] x1 + [1] ok(x1) = [1] x1 + [1] top(x1) = [0] x1 + [0] active^#(x1) = [0] x1 + [0] c_0(x1) = [0] x1 + [0] cons^#(x1, x2) = [1] x1 + [1] x2 + [1] c_1() = [0] c_2() = [0] c_3(x1) = [0] x1 + [0] s^#(x1) = [0] x1 + [0] c_4(x1) = [0] x1 + [0] c_5(x1) = [0] x1 + [0] and^#(x1, x2) = [0] x1 + [0] x2 + [0] c_6(x1) = [0] x1 + [0] length^#(x1) = [0] x1 + [0] c_7(x1) = [0] x1 + [0] c_8(x1) = [1] x1 + [0] c_9(x1) = [0] x1 + [0] c_10(x1) = [0] x1 + [0] c_11(x1) = [0] x1 + [0] proper^#(x1) = [1] x1 + [1] c_12() = [0] c_13(x1) = [1] x1 + [0] c_14() = [0] c_15(x1) = [0] x1 + [0] c_16() = [0] c_17(x1) = [0] x1 + [0] c_18() = [0] c_19(x1) = [0] x1 + [0] c_20(x1) = [1] x1 + [0] c_21(x1) = [0] x1 + [0] c_22(x1) = [0] x1 + [0] c_23(x1) = [0] x1 + [0] top^#(x1) = [0] x1 + [0] c_24(x1) = [0] x1 + [0] c_25(x1) = [0] x1 + [0] Finally we apply the subprocessor We apply the weight gap principle, strictly orienting the rules {proper^#(cons(X1, X2)) -> c_13(cons^#(proper(X1), proper(X2)))} and weakly orienting the rules { cons^#(mark(X1), X2) -> c_8(cons^#(X1, X2)) , cons(ok(X1), ok(X2)) -> ok(cons(X1, X2)) , and(ok(X1), ok(X2)) -> ok(and(X1, X2)) , cons^#(ok(X1), ok(X2)) -> c_20(cons^#(X1, X2))} using the following strongly linear interpretation: Processor 'Matrix Interpretation' oriented the following rules strictly: {proper^#(cons(X1, X2)) -> c_13(cons^#(proper(X1), proper(X2)))} Details: Interpretation Functions: active(x1) = [0] x1 + [0] zeros() = [0] mark(x1) = [1] x1 + [0] cons(x1, x2) = [1] x1 + [1] x2 + [0] 0() = [0] and(x1, x2) = [1] x1 + [1] x2 + [4] tt() = [0] length(x1) = [1] x1 + [0] nil() = [0] s(x1) = [1] x1 + [0] proper(x1) = [1] x1 + [1] ok(x1) = [1] x1 + [1] top(x1) = [0] x1 + [0] active^#(x1) = [0] x1 + [0] c_0(x1) = [0] x1 + [0] cons^#(x1, x2) = [1] x1 + [1] x2 + [0] c_1() = [0] c_2() = [0] c_3(x1) = [0] x1 + [0] s^#(x1) = [0] x1 + [0] c_4(x1) = [0] x1 + [0] c_5(x1) = [0] x1 + [0] and^#(x1, x2) = [0] x1 + [0] x2 + [0] c_6(x1) = [0] x1 + [0] length^#(x1) = [0] x1 + [0] c_7(x1) = [0] x1 + [0] c_8(x1) = [1] x1 + [0] c_9(x1) = [0] x1 + [0] c_10(x1) = [0] x1 + [0] c_11(x1) = [0] x1 + [0] proper^#(x1) = [1] x1 + [9] c_12() = [0] c_13(x1) = [1] x1 + [1] c_14() = [0] c_15(x1) = [0] x1 + [0] c_16() = [0] c_17(x1) = [0] x1 + [0] c_18() = [0] c_19(x1) = [0] x1 + [0] c_20(x1) = [1] x1 + [1] c_21(x1) = [0] x1 + [0] c_22(x1) = [0] x1 + [0] c_23(x1) = [0] x1 + [0] top^#(x1) = [0] x1 + [0] c_24(x1) = [0] x1 + [0] c_25(x1) = [0] x1 + [0] Finally we apply the subprocessor We apply the weight gap principle, strictly orienting the rules { proper(zeros()) -> ok(zeros()) , proper(0()) -> ok(0()) , proper(tt()) -> ok(tt()) , proper(nil()) -> ok(nil())} and weakly orienting the rules { proper^#(cons(X1, X2)) -> c_13(cons^#(proper(X1), proper(X2))) , cons^#(mark(X1), X2) -> c_8(cons^#(X1, X2)) , cons(ok(X1), ok(X2)) -> ok(cons(X1, X2)) , and(ok(X1), ok(X2)) -> ok(and(X1, X2)) , cons^#(ok(X1), ok(X2)) -> c_20(cons^#(X1, X2))} using the following strongly linear interpretation: Processor 'Matrix Interpretation' oriented the following rules strictly: { proper(zeros()) -> ok(zeros()) , proper(0()) -> ok(0()) , proper(tt()) -> ok(tt()) , proper(nil()) -> ok(nil())} Details: Interpretation Functions: active(x1) = [0] x1 + [0] zeros() = [0] mark(x1) = [1] x1 + [0] cons(x1, x2) = [1] x1 + [1] x2 + [0] 0() = [0] and(x1, x2) = [1] x1 + [1] x2 + [10] tt() = [0] length(x1) = [1] x1 + [0] nil() = [7] s(x1) = [1] x1 + [0] proper(x1) = [1] x1 + [1] ok(x1) = [1] x1 + [0] top(x1) = [0] x1 + [0] active^#(x1) = [0] x1 + [0] c_0(x1) = [0] x1 + [0] cons^#(x1, x2) = [1] x1 + [1] x2 + [1] c_1() = [0] c_2() = [0] c_3(x1) = [0] x1 + [0] s^#(x1) = [0] x1 + [0] c_4(x1) = [0] x1 + [0] c_5(x1) = [0] x1 + [0] and^#(x1, x2) = [0] x1 + [0] x2 + [0] c_6(x1) = [0] x1 + [0] length^#(x1) = [0] x1 + [0] c_7(x1) = [0] x1 + [0] c_8(x1) = [1] x1 + [0] c_9(x1) = [0] x1 + [0] c_10(x1) = [0] x1 + [0] c_11(x1) = [0] x1 + [0] proper^#(x1) = [1] x1 + [3] c_12() = [0] c_13(x1) = [1] x1 + [0] c_14() = [0] c_15(x1) = [0] x1 + [0] c_16() = [0] c_17(x1) = [0] x1 + [0] c_18() = [0] c_19(x1) = [0] x1 + [0] c_20(x1) = [1] x1 + [0] c_21(x1) = [0] x1 + [0] c_22(x1) = [0] x1 + [0] c_23(x1) = [0] x1 + [0] top^#(x1) = [0] x1 + [0] c_24(x1) = [0] x1 + [0] c_25(x1) = [0] x1 + [0] Finally we apply the subprocessor 'fastest of 'combine', 'Bounds with default enrichment', 'Bounds with default enrichment'' ------------------------------------------------------------------------------------------ Answer: YES(?,O(n^1)) Input Problem: innermost relative runtime-complexity with respect to Strict Rules: { proper(cons(X1, X2)) -> cons(proper(X1), proper(X2)) , proper(and(X1, X2)) -> and(proper(X1), proper(X2)) , proper(length(X)) -> length(proper(X)) , proper(s(X)) -> s(proper(X)) , length(mark(X)) -> mark(length(X)) , length(ok(X)) -> ok(length(X)) , cons(mark(X1), X2) -> mark(cons(X1, X2)) , and(mark(X1), X2) -> mark(and(X1, X2)) , s(mark(X)) -> mark(s(X)) , s(ok(X)) -> ok(s(X))} Weak Rules: { proper(zeros()) -> ok(zeros()) , proper(0()) -> ok(0()) , proper(tt()) -> ok(tt()) , proper(nil()) -> ok(nil()) , proper^#(cons(X1, X2)) -> c_13(cons^#(proper(X1), proper(X2))) , cons^#(mark(X1), X2) -> c_8(cons^#(X1, X2)) , cons(ok(X1), ok(X2)) -> ok(cons(X1, X2)) , and(ok(X1), ok(X2)) -> ok(and(X1, X2)) , cons^#(ok(X1), ok(X2)) -> c_20(cons^#(X1, X2))} Details: The problem was solved by processor 'Bounds with default enrichment': 'Bounds with default enrichment' -------------------------------- Answer: YES(?,O(n^1)) Input Problem: innermost relative runtime-complexity with respect to Strict Rules: { proper(cons(X1, X2)) -> cons(proper(X1), proper(X2)) , proper(and(X1, X2)) -> and(proper(X1), proper(X2)) , proper(length(X)) -> length(proper(X)) , proper(s(X)) -> s(proper(X)) , length(mark(X)) -> mark(length(X)) , length(ok(X)) -> ok(length(X)) , cons(mark(X1), X2) -> mark(cons(X1, X2)) , and(mark(X1), X2) -> mark(and(X1, X2)) , s(mark(X)) -> mark(s(X)) , s(ok(X)) -> ok(s(X))} Weak Rules: { proper(zeros()) -> ok(zeros()) , proper(0()) -> ok(0()) , proper(tt()) -> ok(tt()) , proper(nil()) -> ok(nil()) , proper^#(cons(X1, X2)) -> c_13(cons^#(proper(X1), proper(X2))) , cons^#(mark(X1), X2) -> c_8(cons^#(X1, X2)) , cons(ok(X1), ok(X2)) -> ok(cons(X1, X2)) , and(ok(X1), ok(X2)) -> ok(and(X1, X2)) , cons^#(ok(X1), ok(X2)) -> c_20(cons^#(X1, X2))} Details: The problem is Match-bounded by 0. The enriched problem is compatible with the following automaton: { zeros_0() -> 2 , mark_0(2) -> 2 , 0_0() -> 2 , tt_0() -> 2 , nil_0() -> 2 , ok_0(2) -> 2 , cons^#_0(2, 2) -> 1 , c_8_0(1) -> 1 , proper^#_0(2) -> 1 , c_20_0(1) -> 1} 7) { proper^#(and(X1, X2)) -> c_15(and^#(proper(X1), proper(X2))) , and^#(ok(X1), ok(X2)) -> c_21(and^#(X1, X2)) , and^#(mark(X1), X2) -> c_9(and^#(X1, X2))} The usable rules for this path are the following: { proper(zeros()) -> ok(zeros()) , proper(cons(X1, X2)) -> cons(proper(X1), proper(X2)) , proper(0()) -> ok(0()) , proper(and(X1, X2)) -> and(proper(X1), proper(X2)) , proper(tt()) -> ok(tt()) , proper(length(X)) -> length(proper(X)) , proper(nil()) -> ok(nil()) , proper(s(X)) -> s(proper(X)) , length(mark(X)) -> mark(length(X)) , length(ok(X)) -> ok(length(X)) , cons(mark(X1), X2) -> mark(cons(X1, X2)) , and(mark(X1), X2) -> mark(and(X1, X2)) , s(mark(X)) -> mark(s(X)) , cons(ok(X1), ok(X2)) -> ok(cons(X1, X2)) , and(ok(X1), ok(X2)) -> ok(and(X1, X2)) , s(ok(X)) -> ok(s(X))} We have applied the subprocessor on the union of usable rules and weak (innermost) dependency pairs. 'Weight Gap Principle' ---------------------- Answer: YES(?,O(n^1)) Input Problem: innermost runtime-complexity with respect to Rules: { proper(zeros()) -> ok(zeros()) , proper(cons(X1, X2)) -> cons(proper(X1), proper(X2)) , proper(0()) -> ok(0()) , proper(and(X1, X2)) -> and(proper(X1), proper(X2)) , proper(tt()) -> ok(tt()) , proper(length(X)) -> length(proper(X)) , proper(nil()) -> ok(nil()) , proper(s(X)) -> s(proper(X)) , length(mark(X)) -> mark(length(X)) , length(ok(X)) -> ok(length(X)) , cons(mark(X1), X2) -> mark(cons(X1, X2)) , and(mark(X1), X2) -> mark(and(X1, X2)) , s(mark(X)) -> mark(s(X)) , cons(ok(X1), ok(X2)) -> ok(cons(X1, X2)) , and(ok(X1), ok(X2)) -> ok(and(X1, X2)) , s(ok(X)) -> ok(s(X)) , proper^#(and(X1, X2)) -> c_15(and^#(proper(X1), proper(X2))) , and^#(ok(X1), ok(X2)) -> c_21(and^#(X1, X2)) , and^#(mark(X1), X2) -> c_9(and^#(X1, X2))} Details: We apply the weight gap principle, strictly orienting the rules { cons(ok(X1), ok(X2)) -> ok(cons(X1, X2)) , and(ok(X1), ok(X2)) -> ok(and(X1, X2)) , and^#(ok(X1), ok(X2)) -> c_21(and^#(X1, X2))} and weakly orienting the rules {} using the following strongly linear interpretation: Processor 'Matrix Interpretation' oriented the following rules strictly: { cons(ok(X1), ok(X2)) -> ok(cons(X1, X2)) , and(ok(X1), ok(X2)) -> ok(and(X1, X2)) , and^#(ok(X1), ok(X2)) -> c_21(and^#(X1, X2))} Details: Interpretation Functions: active(x1) = [0] x1 + [0] zeros() = [0] mark(x1) = [1] x1 + [0] cons(x1, x2) = [1] x1 + [1] x2 + [0] 0() = [0] and(x1, x2) = [1] x1 + [1] x2 + [0] tt() = [0] length(x1) = [1] x1 + [0] nil() = [0] s(x1) = [1] x1 + [1] proper(x1) = [1] x1 + [1] ok(x1) = [1] x1 + [1] top(x1) = [0] x1 + [0] active^#(x1) = [0] x1 + [0] c_0(x1) = [0] x1 + [0] cons^#(x1, x2) = [0] x1 + [0] x2 + [0] c_1() = [0] c_2() = [0] c_3(x1) = [0] x1 + [0] s^#(x1) = [0] x1 + [0] c_4(x1) = [0] x1 + [0] c_5(x1) = [0] x1 + [0] and^#(x1, x2) = [1] x1 + [1] x2 + [0] c_6(x1) = [0] x1 + [0] length^#(x1) = [0] x1 + [0] c_7(x1) = [0] x1 + [0] c_8(x1) = [0] x1 + [0] c_9(x1) = [1] x1 + [1] c_10(x1) = [0] x1 + [0] c_11(x1) = [0] x1 + [0] proper^#(x1) = [1] x1 + [1] c_12() = [0] c_13(x1) = [0] x1 + [0] c_14() = [0] c_15(x1) = [1] x1 + [1] c_16() = [0] c_17(x1) = [0] x1 + [0] c_18() = [0] c_19(x1) = [0] x1 + [0] c_20(x1) = [0] x1 + [0] c_21(x1) = [1] x1 + [1] c_22(x1) = [0] x1 + [0] c_23(x1) = [0] x1 + [0] top^#(x1) = [0] x1 + [0] c_24(x1) = [0] x1 + [0] c_25(x1) = [0] x1 + [0] Finally we apply the subprocessor We apply the weight gap principle, strictly orienting the rules {and^#(mark(X1), X2) -> c_9(and^#(X1, X2))} and weakly orienting the rules { cons(ok(X1), ok(X2)) -> ok(cons(X1, X2)) , and(ok(X1), ok(X2)) -> ok(and(X1, X2)) , and^#(ok(X1), ok(X2)) -> c_21(and^#(X1, X2))} using the following strongly linear interpretation: Processor 'Matrix Interpretation' oriented the following rules strictly: {and^#(mark(X1), X2) -> c_9(and^#(X1, X2))} Details: Interpretation Functions: active(x1) = [0] x1 + [0] zeros() = [0] mark(x1) = [1] x1 + [2] cons(x1, x2) = [1] x1 + [1] x2 + [0] 0() = [0] and(x1, x2) = [1] x1 + [1] x2 + [0] tt() = [0] length(x1) = [1] x1 + [2] nil() = [0] s(x1) = [1] x1 + [0] proper(x1) = [1] x1 + [1] ok(x1) = [1] x1 + [1] top(x1) = [0] x1 + [0] active^#(x1) = [0] x1 + [0] c_0(x1) = [0] x1 + [0] cons^#(x1, x2) = [0] x1 + [0] x2 + [0] c_1() = [0] c_2() = [0] c_3(x1) = [0] x1 + [0] s^#(x1) = [0] x1 + [0] c_4(x1) = [0] x1 + [0] c_5(x1) = [0] x1 + [0] and^#(x1, x2) = [1] x1 + [1] x2 + [1] c_6(x1) = [0] x1 + [0] length^#(x1) = [0] x1 + [0] c_7(x1) = [0] x1 + [0] c_8(x1) = [0] x1 + [0] c_9(x1) = [1] x1 + [0] c_10(x1) = [0] x1 + [0] c_11(x1) = [0] x1 + [0] proper^#(x1) = [1] x1 + [1] c_12() = [0] c_13(x1) = [0] x1 + [0] c_14() = [0] c_15(x1) = [1] x1 + [0] c_16() = [0] c_17(x1) = [0] x1 + [0] c_18() = [0] c_19(x1) = [0] x1 + [0] c_20(x1) = [0] x1 + [0] c_21(x1) = [1] x1 + [0] c_22(x1) = [0] x1 + [0] c_23(x1) = [0] x1 + [0] top^#(x1) = [0] x1 + [0] c_24(x1) = [0] x1 + [0] c_25(x1) = [0] x1 + [0] Finally we apply the subprocessor We apply the weight gap principle, strictly orienting the rules {proper^#(and(X1, X2)) -> c_15(and^#(proper(X1), proper(X2)))} and weakly orienting the rules { and^#(mark(X1), X2) -> c_9(and^#(X1, X2)) , cons(ok(X1), ok(X2)) -> ok(cons(X1, X2)) , and(ok(X1), ok(X2)) -> ok(and(X1, X2)) , and^#(ok(X1), ok(X2)) -> c_21(and^#(X1, X2))} using the following strongly linear interpretation: Processor 'Matrix Interpretation' oriented the following rules strictly: {proper^#(and(X1, X2)) -> c_15(and^#(proper(X1), proper(X2)))} Details: Interpretation Functions: active(x1) = [0] x1 + [0] zeros() = [0] mark(x1) = [1] x1 + [0] cons(x1, x2) = [1] x1 + [1] x2 + [0] 0() = [0] and(x1, x2) = [1] x1 + [1] x2 + [4] tt() = [0] length(x1) = [1] x1 + [0] nil() = [0] s(x1) = [1] x1 + [0] proper(x1) = [1] x1 + [1] ok(x1) = [1] x1 + [1] top(x1) = [0] x1 + [0] active^#(x1) = [0] x1 + [0] c_0(x1) = [0] x1 + [0] cons^#(x1, x2) = [0] x1 + [0] x2 + [0] c_1() = [0] c_2() = [0] c_3(x1) = [0] x1 + [0] s^#(x1) = [0] x1 + [0] c_4(x1) = [0] x1 + [0] c_5(x1) = [0] x1 + [0] and^#(x1, x2) = [1] x1 + [1] x2 + [0] c_6(x1) = [0] x1 + [0] length^#(x1) = [0] x1 + [0] c_7(x1) = [0] x1 + [0] c_8(x1) = [0] x1 + [0] c_9(x1) = [1] x1 + [0] c_10(x1) = [0] x1 + [0] c_11(x1) = [0] x1 + [0] proper^#(x1) = [1] x1 + [1] c_12() = [0] c_13(x1) = [0] x1 + [0] c_14() = [0] c_15(x1) = [1] x1 + [1] c_16() = [0] c_17(x1) = [0] x1 + [0] c_18() = [0] c_19(x1) = [0] x1 + [0] c_20(x1) = [0] x1 + [0] c_21(x1) = [1] x1 + [1] c_22(x1) = [0] x1 + [0] c_23(x1) = [0] x1 + [0] top^#(x1) = [0] x1 + [0] c_24(x1) = [0] x1 + [0] c_25(x1) = [0] x1 + [0] Finally we apply the subprocessor We apply the weight gap principle, strictly orienting the rules { proper(zeros()) -> ok(zeros()) , proper(0()) -> ok(0()) , proper(tt()) -> ok(tt()) , proper(nil()) -> ok(nil())} and weakly orienting the rules { proper^#(and(X1, X2)) -> c_15(and^#(proper(X1), proper(X2))) , and^#(mark(X1), X2) -> c_9(and^#(X1, X2)) , cons(ok(X1), ok(X2)) -> ok(cons(X1, X2)) , and(ok(X1), ok(X2)) -> ok(and(X1, X2)) , and^#(ok(X1), ok(X2)) -> c_21(and^#(X1, X2))} using the following strongly linear interpretation: Processor 'Matrix Interpretation' oriented the following rules strictly: { proper(zeros()) -> ok(zeros()) , proper(0()) -> ok(0()) , proper(tt()) -> ok(tt()) , proper(nil()) -> ok(nil())} Details: Interpretation Functions: active(x1) = [0] x1 + [0] zeros() = [0] mark(x1) = [1] x1 + [0] cons(x1, x2) = [1] x1 + [1] x2 + [0] 0() = [0] and(x1, x2) = [1] x1 + [1] x2 + [8] tt() = [0] length(x1) = [1] x1 + [0] nil() = [8] s(x1) = [1] x1 + [0] proper(x1) = [1] x1 + [1] ok(x1) = [1] x1 + [0] top(x1) = [0] x1 + [0] active^#(x1) = [0] x1 + [0] c_0(x1) = [0] x1 + [0] cons^#(x1, x2) = [0] x1 + [0] x2 + [0] c_1() = [0] c_2() = [0] c_3(x1) = [0] x1 + [0] s^#(x1) = [0] x1 + [0] c_4(x1) = [0] x1 + [0] c_5(x1) = [0] x1 + [0] and^#(x1, x2) = [1] x1 + [1] x2 + [1] c_6(x1) = [0] x1 + [0] length^#(x1) = [0] x1 + [0] c_7(x1) = [0] x1 + [0] c_8(x1) = [0] x1 + [0] c_9(x1) = [1] x1 + [0] c_10(x1) = [0] x1 + [0] c_11(x1) = [0] x1 + [0] proper^#(x1) = [1] x1 + [0] c_12() = [0] c_13(x1) = [0] x1 + [0] c_14() = [0] c_15(x1) = [1] x1 + [0] c_16() = [0] c_17(x1) = [0] x1 + [0] c_18() = [0] c_19(x1) = [0] x1 + [0] c_20(x1) = [0] x1 + [0] c_21(x1) = [1] x1 + [0] c_22(x1) = [0] x1 + [0] c_23(x1) = [0] x1 + [0] top^#(x1) = [0] x1 + [0] c_24(x1) = [0] x1 + [0] c_25(x1) = [0] x1 + [0] Finally we apply the subprocessor 'fastest of 'combine', 'Bounds with default enrichment', 'Bounds with default enrichment'' ------------------------------------------------------------------------------------------ Answer: YES(?,O(n^1)) Input Problem: innermost relative runtime-complexity with respect to Strict Rules: { proper(cons(X1, X2)) -> cons(proper(X1), proper(X2)) , proper(and(X1, X2)) -> and(proper(X1), proper(X2)) , proper(length(X)) -> length(proper(X)) , proper(s(X)) -> s(proper(X)) , length(mark(X)) -> mark(length(X)) , length(ok(X)) -> ok(length(X)) , cons(mark(X1), X2) -> mark(cons(X1, X2)) , and(mark(X1), X2) -> mark(and(X1, X2)) , s(mark(X)) -> mark(s(X)) , s(ok(X)) -> ok(s(X))} Weak Rules: { proper(zeros()) -> ok(zeros()) , proper(0()) -> ok(0()) , proper(tt()) -> ok(tt()) , proper(nil()) -> ok(nil()) , proper^#(and(X1, X2)) -> c_15(and^#(proper(X1), proper(X2))) , and^#(mark(X1), X2) -> c_9(and^#(X1, X2)) , cons(ok(X1), ok(X2)) -> ok(cons(X1, X2)) , and(ok(X1), ok(X2)) -> ok(and(X1, X2)) , and^#(ok(X1), ok(X2)) -> c_21(and^#(X1, X2))} Details: The problem was solved by processor 'Bounds with default enrichment': 'Bounds with default enrichment' -------------------------------- Answer: YES(?,O(n^1)) Input Problem: innermost relative runtime-complexity with respect to Strict Rules: { proper(cons(X1, X2)) -> cons(proper(X1), proper(X2)) , proper(and(X1, X2)) -> and(proper(X1), proper(X2)) , proper(length(X)) -> length(proper(X)) , proper(s(X)) -> s(proper(X)) , length(mark(X)) -> mark(length(X)) , length(ok(X)) -> ok(length(X)) , cons(mark(X1), X2) -> mark(cons(X1, X2)) , and(mark(X1), X2) -> mark(and(X1, X2)) , s(mark(X)) -> mark(s(X)) , s(ok(X)) -> ok(s(X))} Weak Rules: { proper(zeros()) -> ok(zeros()) , proper(0()) -> ok(0()) , proper(tt()) -> ok(tt()) , proper(nil()) -> ok(nil()) , proper^#(and(X1, X2)) -> c_15(and^#(proper(X1), proper(X2))) , and^#(mark(X1), X2) -> c_9(and^#(X1, X2)) , cons(ok(X1), ok(X2)) -> ok(cons(X1, X2)) , and(ok(X1), ok(X2)) -> ok(and(X1, X2)) , and^#(ok(X1), ok(X2)) -> c_21(and^#(X1, X2))} Details: The problem is Match-bounded by 0. The enriched problem is compatible with the following automaton: { zeros_0() -> 2 , mark_0(2) -> 2 , 0_0() -> 2 , tt_0() -> 2 , nil_0() -> 2 , ok_0(2) -> 2 , and^#_0(2, 2) -> 1 , c_9_0(1) -> 1 , proper^#_0(2) -> 1 , c_21_0(1) -> 1} 8) {active^#(cons(X1, X2)) -> c_4(cons^#(active(X1), X2))} The usable rules for this path are the following: { active(zeros()) -> mark(cons(0(), zeros())) , active(and(tt(), X)) -> mark(X) , active(length(nil())) -> mark(0()) , active(length(cons(N, L))) -> mark(s(length(L))) , active(cons(X1, X2)) -> cons(active(X1), X2) , active(and(X1, X2)) -> and(active(X1), X2) , active(length(X)) -> length(active(X)) , active(s(X)) -> s(active(X)) , length(mark(X)) -> mark(length(X)) , length(ok(X)) -> ok(length(X)) , cons(mark(X1), X2) -> mark(cons(X1, X2)) , and(mark(X1), X2) -> mark(and(X1, X2)) , s(mark(X)) -> mark(s(X)) , cons(ok(X1), ok(X2)) -> ok(cons(X1, X2)) , and(ok(X1), ok(X2)) -> ok(and(X1, X2)) , s(ok(X)) -> ok(s(X))} We have applied the subprocessor on the union of usable rules and weak (innermost) dependency pairs. 'Weight Gap Principle' ---------------------- Answer: YES(?,O(n^1)) Input Problem: innermost runtime-complexity with respect to Rules: { active(zeros()) -> mark(cons(0(), zeros())) , active(and(tt(), X)) -> mark(X) , active(length(nil())) -> mark(0()) , active(length(cons(N, L))) -> mark(s(length(L))) , active(cons(X1, X2)) -> cons(active(X1), X2) , active(and(X1, X2)) -> and(active(X1), X2) , active(length(X)) -> length(active(X)) , active(s(X)) -> s(active(X)) , length(mark(X)) -> mark(length(X)) , length(ok(X)) -> ok(length(X)) , cons(mark(X1), X2) -> mark(cons(X1, X2)) , and(mark(X1), X2) -> mark(and(X1, X2)) , s(mark(X)) -> mark(s(X)) , cons(ok(X1), ok(X2)) -> ok(cons(X1, X2)) , and(ok(X1), ok(X2)) -> ok(and(X1, X2)) , s(ok(X)) -> ok(s(X)) , active^#(cons(X1, X2)) -> c_4(cons^#(active(X1), X2))} Details: We apply the weight gap principle, strictly orienting the rules {active^#(cons(X1, X2)) -> c_4(cons^#(active(X1), X2))} and weakly orienting the rules {} using the following strongly linear interpretation: Processor 'Matrix Interpretation' oriented the following rules strictly: {active^#(cons(X1, X2)) -> c_4(cons^#(active(X1), X2))} Details: Interpretation Functions: active(x1) = [1] x1 + [1] zeros() = [0] mark(x1) = [1] x1 + [1] cons(x1, x2) = [1] x1 + [1] x2 + [0] 0() = [0] and(x1, x2) = [1] x1 + [1] x2 + [0] tt() = [0] length(x1) = [1] x1 + [0] nil() = [0] s(x1) = [1] x1 + [0] proper(x1) = [0] x1 + [0] ok(x1) = [1] x1 + [0] top(x1) = [0] x1 + [0] active^#(x1) = [1] x1 + [11] c_0(x1) = [0] x1 + [0] cons^#(x1, x2) = [1] x1 + [1] x2 + [8] c_1() = [0] c_2() = [0] c_3(x1) = [0] x1 + [0] s^#(x1) = [0] x1 + [0] c_4(x1) = [1] x1 + [0] c_5(x1) = [0] x1 + [0] and^#(x1, x2) = [0] x1 + [0] x2 + [0] c_6(x1) = [0] x1 + [0] length^#(x1) = [0] x1 + [0] c_7(x1) = [0] x1 + [0] c_8(x1) = [0] x1 + [0] c_9(x1) = [0] x1 + [0] c_10(x1) = [0] x1 + [0] c_11(x1) = [0] x1 + [0] proper^#(x1) = [0] x1 + [0] c_12() = [0] c_13(x1) = [0] x1 + [0] c_14() = [0] c_15(x1) = [0] x1 + [0] c_16() = [0] c_17(x1) = [0] x1 + [0] c_18() = [0] c_19(x1) = [0] x1 + [0] c_20(x1) = [0] x1 + [0] c_21(x1) = [0] x1 + [0] c_22(x1) = [0] x1 + [0] c_23(x1) = [0] x1 + [0] top^#(x1) = [0] x1 + [0] c_24(x1) = [0] x1 + [0] c_25(x1) = [0] x1 + [0] Finally we apply the subprocessor We apply the weight gap principle, strictly orienting the rules { cons(ok(X1), ok(X2)) -> ok(cons(X1, X2)) , and(ok(X1), ok(X2)) -> ok(and(X1, X2))} and weakly orienting the rules {active^#(cons(X1, X2)) -> c_4(cons^#(active(X1), X2))} using the following strongly linear interpretation: Processor 'Matrix Interpretation' oriented the following rules strictly: { cons(ok(X1), ok(X2)) -> ok(cons(X1, X2)) , and(ok(X1), ok(X2)) -> ok(and(X1, X2))} Details: Interpretation Functions: active(x1) = [1] x1 + [1] zeros() = [0] mark(x1) = [1] x1 + [1] cons(x1, x2) = [1] x1 + [1] x2 + [0] 0() = [0] and(x1, x2) = [1] x1 + [1] x2 + [0] tt() = [0] length(x1) = [1] x1 + [0] nil() = [0] s(x1) = [1] x1 + [0] proper(x1) = [0] x1 + [0] ok(x1) = [1] x1 + [8] top(x1) = [0] x1 + [0] active^#(x1) = [1] x1 + [9] c_0(x1) = [0] x1 + [0] cons^#(x1, x2) = [1] x1 + [1] x2 + [7] c_1() = [0] c_2() = [0] c_3(x1) = [0] x1 + [0] s^#(x1) = [0] x1 + [0] c_4(x1) = [1] x1 + [1] c_5(x1) = [0] x1 + [0] and^#(x1, x2) = [0] x1 + [0] x2 + [0] c_6(x1) = [0] x1 + [0] length^#(x1) = [0] x1 + [0] c_7(x1) = [0] x1 + [0] c_8(x1) = [0] x1 + [0] c_9(x1) = [0] x1 + [0] c_10(x1) = [0] x1 + [0] c_11(x1) = [0] x1 + [0] proper^#(x1) = [0] x1 + [0] c_12() = [0] c_13(x1) = [0] x1 + [0] c_14() = [0] c_15(x1) = [0] x1 + [0] c_16() = [0] c_17(x1) = [0] x1 + [0] c_18() = [0] c_19(x1) = [0] x1 + [0] c_20(x1) = [0] x1 + [0] c_21(x1) = [0] x1 + [0] c_22(x1) = [0] x1 + [0] c_23(x1) = [0] x1 + [0] top^#(x1) = [0] x1 + [0] c_24(x1) = [0] x1 + [0] c_25(x1) = [0] x1 + [0] Finally we apply the subprocessor We apply the weight gap principle, strictly orienting the rules {active(length(nil())) -> mark(0())} and weakly orienting the rules { cons(ok(X1), ok(X2)) -> ok(cons(X1, X2)) , and(ok(X1), ok(X2)) -> ok(and(X1, X2)) , active^#(cons(X1, X2)) -> c_4(cons^#(active(X1), X2))} using the following strongly linear interpretation: Processor 'Matrix Interpretation' oriented the following rules strictly: {active(length(nil())) -> mark(0())} Details: Interpretation Functions: active(x1) = [1] x1 + [1] zeros() = [0] mark(x1) = [1] x1 + [1] cons(x1, x2) = [1] x1 + [1] x2 + [0] 0() = [0] and(x1, x2) = [1] x1 + [1] x2 + [0] tt() = [0] length(x1) = [1] x1 + [8] nil() = [0] s(x1) = [1] x1 + [0] proper(x1) = [0] x1 + [0] ok(x1) = [1] x1 + [0] top(x1) = [0] x1 + [0] active^#(x1) = [1] x1 + [1] c_0(x1) = [0] x1 + [0] cons^#(x1, x2) = [1] x1 + [1] x2 + [0] c_1() = [0] c_2() = [0] c_3(x1) = [0] x1 + [0] s^#(x1) = [0] x1 + [0] c_4(x1) = [1] x1 + [0] c_5(x1) = [0] x1 + [0] and^#(x1, x2) = [0] x1 + [0] x2 + [0] c_6(x1) = [0] x1 + [0] length^#(x1) = [0] x1 + [0] c_7(x1) = [0] x1 + [0] c_8(x1) = [0] x1 + [0] c_9(x1) = [0] x1 + [0] c_10(x1) = [0] x1 + [0] c_11(x1) = [0] x1 + [0] proper^#(x1) = [0] x1 + [0] c_12() = [0] c_13(x1) = [0] x1 + [0] c_14() = [0] c_15(x1) = [0] x1 + [0] c_16() = [0] c_17(x1) = [0] x1 + [0] c_18() = [0] c_19(x1) = [0] x1 + [0] c_20(x1) = [0] x1 + [0] c_21(x1) = [0] x1 + [0] c_22(x1) = [0] x1 + [0] c_23(x1) = [0] x1 + [0] top^#(x1) = [0] x1 + [0] c_24(x1) = [0] x1 + [0] c_25(x1) = [0] x1 + [0] Finally we apply the subprocessor We apply the weight gap principle, strictly orienting the rules { active(and(tt(), X)) -> mark(X) , active(length(cons(N, L))) -> mark(s(length(L)))} and weakly orienting the rules { active(length(nil())) -> mark(0()) , cons(ok(X1), ok(X2)) -> ok(cons(X1, X2)) , and(ok(X1), ok(X2)) -> ok(and(X1, X2)) , active^#(cons(X1, X2)) -> c_4(cons^#(active(X1), X2))} using the following strongly linear interpretation: Processor 'Matrix Interpretation' oriented the following rules strictly: { active(and(tt(), X)) -> mark(X) , active(length(cons(N, L))) -> mark(s(length(L)))} Details: Interpretation Functions: active(x1) = [1] x1 + [0] zeros() = [0] mark(x1) = [1] x1 + [0] cons(x1, x2) = [1] x1 + [1] x2 + [6] 0() = [1] and(x1, x2) = [1] x1 + [1] x2 + [0] tt() = [1] length(x1) = [1] x1 + [0] nil() = [9] s(x1) = [1] x1 + [0] proper(x1) = [0] x1 + [0] ok(x1) = [1] x1 + [0] top(x1) = [0] x1 + [0] active^#(x1) = [1] x1 + [13] c_0(x1) = [0] x1 + [0] cons^#(x1, x2) = [1] x1 + [1] x2 + [0] c_1() = [0] c_2() = [0] c_3(x1) = [0] x1 + [0] s^#(x1) = [0] x1 + [0] c_4(x1) = [1] x1 + [5] c_5(x1) = [0] x1 + [0] and^#(x1, x2) = [0] x1 + [0] x2 + [0] c_6(x1) = [0] x1 + [0] length^#(x1) = [0] x1 + [0] c_7(x1) = [0] x1 + [0] c_8(x1) = [0] x1 + [0] c_9(x1) = [0] x1 + [0] c_10(x1) = [0] x1 + [0] c_11(x1) = [0] x1 + [0] proper^#(x1) = [0] x1 + [0] c_12() = [0] c_13(x1) = [0] x1 + [0] c_14() = [0] c_15(x1) = [0] x1 + [0] c_16() = [0] c_17(x1) = [0] x1 + [0] c_18() = [0] c_19(x1) = [0] x1 + [0] c_20(x1) = [0] x1 + [0] c_21(x1) = [0] x1 + [0] c_22(x1) = [0] x1 + [0] c_23(x1) = [0] x1 + [0] top^#(x1) = [0] x1 + [0] c_24(x1) = [0] x1 + [0] c_25(x1) = [0] x1 + [0] Finally we apply the subprocessor We apply the weight gap principle, strictly orienting the rules {active(zeros()) -> mark(cons(0(), zeros()))} and weakly orienting the rules { active(and(tt(), X)) -> mark(X) , active(length(cons(N, L))) -> mark(s(length(L))) , active(length(nil())) -> mark(0()) , cons(ok(X1), ok(X2)) -> ok(cons(X1, X2)) , and(ok(X1), ok(X2)) -> ok(and(X1, X2)) , active^#(cons(X1, X2)) -> c_4(cons^#(active(X1), X2))} using the following strongly linear interpretation: Processor 'Matrix Interpretation' oriented the following rules strictly: {active(zeros()) -> mark(cons(0(), zeros()))} Details: Interpretation Functions: active(x1) = [1] x1 + [8] zeros() = [0] mark(x1) = [1] x1 + [0] cons(x1, x2) = [1] x1 + [1] x2 + [0] 0() = [0] and(x1, x2) = [1] x1 + [1] x2 + [0] tt() = [8] length(x1) = [1] x1 + [0] nil() = [9] s(x1) = [1] x1 + [0] proper(x1) = [0] x1 + [0] ok(x1) = [1] x1 + [0] top(x1) = [0] x1 + [0] active^#(x1) = [1] x1 + [15] c_0(x1) = [0] x1 + [0] cons^#(x1, x2) = [1] x1 + [1] x2 + [1] c_1() = [0] c_2() = [0] c_3(x1) = [0] x1 + [0] s^#(x1) = [0] x1 + [0] c_4(x1) = [1] x1 + [0] c_5(x1) = [0] x1 + [0] and^#(x1, x2) = [0] x1 + [0] x2 + [0] c_6(x1) = [0] x1 + [0] length^#(x1) = [0] x1 + [0] c_7(x1) = [0] x1 + [0] c_8(x1) = [0] x1 + [0] c_9(x1) = [0] x1 + [0] c_10(x1) = [0] x1 + [0] c_11(x1) = [0] x1 + [0] proper^#(x1) = [0] x1 + [0] c_12() = [0] c_13(x1) = [0] x1 + [0] c_14() = [0] c_15(x1) = [0] x1 + [0] c_16() = [0] c_17(x1) = [0] x1 + [0] c_18() = [0] c_19(x1) = [0] x1 + [0] c_20(x1) = [0] x1 + [0] c_21(x1) = [0] x1 + [0] c_22(x1) = [0] x1 + [0] c_23(x1) = [0] x1 + [0] top^#(x1) = [0] x1 + [0] c_24(x1) = [0] x1 + [0] c_25(x1) = [0] x1 + [0] Finally we apply the subprocessor 'fastest of 'combine', 'Bounds with default enrichment', 'Bounds with default enrichment'' ------------------------------------------------------------------------------------------ Answer: YES(?,O(n^1)) Input Problem: innermost relative runtime-complexity with respect to Strict Rules: { active(cons(X1, X2)) -> cons(active(X1), X2) , active(and(X1, X2)) -> and(active(X1), X2) , active(length(X)) -> length(active(X)) , active(s(X)) -> s(active(X)) , length(mark(X)) -> mark(length(X)) , length(ok(X)) -> ok(length(X)) , cons(mark(X1), X2) -> mark(cons(X1, X2)) , and(mark(X1), X2) -> mark(and(X1, X2)) , s(mark(X)) -> mark(s(X)) , s(ok(X)) -> ok(s(X))} Weak Rules: { active(zeros()) -> mark(cons(0(), zeros())) , active(and(tt(), X)) -> mark(X) , active(length(cons(N, L))) -> mark(s(length(L))) , active(length(nil())) -> mark(0()) , cons(ok(X1), ok(X2)) -> ok(cons(X1, X2)) , and(ok(X1), ok(X2)) -> ok(and(X1, X2)) , active^#(cons(X1, X2)) -> c_4(cons^#(active(X1), X2))} Details: The problem was solved by processor 'Bounds with default enrichment': 'Bounds with default enrichment' -------------------------------- Answer: YES(?,O(n^1)) Input Problem: innermost relative runtime-complexity with respect to Strict Rules: { active(cons(X1, X2)) -> cons(active(X1), X2) , active(and(X1, X2)) -> and(active(X1), X2) , active(length(X)) -> length(active(X)) , active(s(X)) -> s(active(X)) , length(mark(X)) -> mark(length(X)) , length(ok(X)) -> ok(length(X)) , cons(mark(X1), X2) -> mark(cons(X1, X2)) , and(mark(X1), X2) -> mark(and(X1, X2)) , s(mark(X)) -> mark(s(X)) , s(ok(X)) -> ok(s(X))} Weak Rules: { active(zeros()) -> mark(cons(0(), zeros())) , active(and(tt(), X)) -> mark(X) , active(length(cons(N, L))) -> mark(s(length(L))) , active(length(nil())) -> mark(0()) , cons(ok(X1), ok(X2)) -> ok(cons(X1, X2)) , and(ok(X1), ok(X2)) -> ok(and(X1, X2)) , active^#(cons(X1, X2)) -> c_4(cons^#(active(X1), X2))} Details: The problem is Match-bounded by 0. The enriched problem is compatible with the following automaton: { zeros_0() -> 2 , mark_0(2) -> 3 , mark_0(3) -> 3 , mark_0(5) -> 3 , mark_0(7) -> 3 , mark_0(9) -> 3 , mark_0(12) -> 3 , 0_0() -> 5 , tt_0() -> 7 , nil_0() -> 9 , ok_0(2) -> 12 , ok_0(3) -> 12 , ok_0(5) -> 12 , ok_0(7) -> 12 , ok_0(9) -> 12 , ok_0(12) -> 12 , active^#_0(2) -> 14 , active^#_0(3) -> 14 , active^#_0(5) -> 14 , active^#_0(7) -> 14 , active^#_0(9) -> 14 , active^#_0(12) -> 14 , cons^#_0(2, 2) -> 16 , cons^#_0(2, 3) -> 16 , cons^#_0(2, 5) -> 16 , cons^#_0(2, 7) -> 16 , cons^#_0(2, 9) -> 16 , cons^#_0(2, 12) -> 16 , cons^#_0(3, 2) -> 16 , cons^#_0(3, 3) -> 16 , cons^#_0(3, 5) -> 16 , cons^#_0(3, 7) -> 16 , cons^#_0(3, 9) -> 16 , cons^#_0(3, 12) -> 16 , cons^#_0(5, 2) -> 16 , cons^#_0(5, 3) -> 16 , cons^#_0(5, 5) -> 16 , cons^#_0(5, 7) -> 16 , cons^#_0(5, 9) -> 16 , cons^#_0(5, 12) -> 16 , cons^#_0(7, 2) -> 16 , cons^#_0(7, 3) -> 16 , cons^#_0(7, 5) -> 16 , cons^#_0(7, 7) -> 16 , cons^#_0(7, 9) -> 16 , cons^#_0(7, 12) -> 16 , cons^#_0(9, 2) -> 16 , cons^#_0(9, 3) -> 16 , cons^#_0(9, 5) -> 16 , cons^#_0(9, 7) -> 16 , cons^#_0(9, 9) -> 16 , cons^#_0(9, 12) -> 16 , cons^#_0(12, 2) -> 16 , cons^#_0(12, 3) -> 16 , cons^#_0(12, 5) -> 16 , cons^#_0(12, 7) -> 16 , cons^#_0(12, 9) -> 16 , cons^#_0(12, 12) -> 16} 9) {active^#(s(X)) -> c_7(s^#(active(X)))} The usable rules for this path are the following: { active(zeros()) -> mark(cons(0(), zeros())) , active(and(tt(), X)) -> mark(X) , active(length(nil())) -> mark(0()) , active(length(cons(N, L))) -> mark(s(length(L))) , active(cons(X1, X2)) -> cons(active(X1), X2) , active(and(X1, X2)) -> and(active(X1), X2) , active(length(X)) -> length(active(X)) , active(s(X)) -> s(active(X)) , length(mark(X)) -> mark(length(X)) , length(ok(X)) -> ok(length(X)) , cons(mark(X1), X2) -> mark(cons(X1, X2)) , and(mark(X1), X2) -> mark(and(X1, X2)) , s(mark(X)) -> mark(s(X)) , cons(ok(X1), ok(X2)) -> ok(cons(X1, X2)) , and(ok(X1), ok(X2)) -> ok(and(X1, X2)) , s(ok(X)) -> ok(s(X))} We have applied the subprocessor on the union of usable rules and weak (innermost) dependency pairs. 'Weight Gap Principle' ---------------------- Answer: YES(?,O(n^1)) Input Problem: innermost runtime-complexity with respect to Rules: { active(zeros()) -> mark(cons(0(), zeros())) , active(and(tt(), X)) -> mark(X) , active(length(nil())) -> mark(0()) , active(length(cons(N, L))) -> mark(s(length(L))) , active(cons(X1, X2)) -> cons(active(X1), X2) , active(and(X1, X2)) -> and(active(X1), X2) , active(length(X)) -> length(active(X)) , active(s(X)) -> s(active(X)) , length(mark(X)) -> mark(length(X)) , length(ok(X)) -> ok(length(X)) , cons(mark(X1), X2) -> mark(cons(X1, X2)) , and(mark(X1), X2) -> mark(and(X1, X2)) , s(mark(X)) -> mark(s(X)) , cons(ok(X1), ok(X2)) -> ok(cons(X1, X2)) , and(ok(X1), ok(X2)) -> ok(and(X1, X2)) , s(ok(X)) -> ok(s(X)) , active^#(s(X)) -> c_7(s^#(active(X)))} Details: We apply the weight gap principle, strictly orienting the rules { cons(ok(X1), ok(X2)) -> ok(cons(X1, X2)) , and(ok(X1), ok(X2)) -> ok(and(X1, X2))} and weakly orienting the rules {} using the following strongly linear interpretation: Processor 'Matrix Interpretation' oriented the following rules strictly: { cons(ok(X1), ok(X2)) -> ok(cons(X1, X2)) , and(ok(X1), ok(X2)) -> ok(and(X1, X2))} Details: Interpretation Functions: active(x1) = [1] x1 + [1] zeros() = [0] mark(x1) = [1] x1 + [1] cons(x1, x2) = [1] x1 + [1] x2 + [0] 0() = [0] and(x1, x2) = [1] x1 + [1] x2 + [0] tt() = [0] length(x1) = [1] x1 + [0] nil() = [0] s(x1) = [1] x1 + [0] proper(x1) = [0] x1 + [0] ok(x1) = [1] x1 + [8] top(x1) = [0] x1 + [0] active^#(x1) = [1] x1 + [1] c_0(x1) = [0] x1 + [0] cons^#(x1, x2) = [0] x1 + [0] x2 + [0] c_1() = [0] c_2() = [0] c_3(x1) = [0] x1 + [0] s^#(x1) = [1] x1 + [7] c_4(x1) = [0] x1 + [0] c_5(x1) = [0] x1 + [0] and^#(x1, x2) = [0] x1 + [0] x2 + [0] c_6(x1) = [0] x1 + [0] length^#(x1) = [0] x1 + [0] c_7(x1) = [1] x1 + [9] c_8(x1) = [0] x1 + [0] c_9(x1) = [0] x1 + [0] c_10(x1) = [0] x1 + [0] c_11(x1) = [0] x1 + [0] proper^#(x1) = [0] x1 + [0] c_12() = [0] c_13(x1) = [0] x1 + [0] c_14() = [0] c_15(x1) = [0] x1 + [0] c_16() = [0] c_17(x1) = [0] x1 + [0] c_18() = [0] c_19(x1) = [0] x1 + [0] c_20(x1) = [0] x1 + [0] c_21(x1) = [0] x1 + [0] c_22(x1) = [0] x1 + [0] c_23(x1) = [0] x1 + [0] top^#(x1) = [0] x1 + [0] c_24(x1) = [0] x1 + [0] c_25(x1) = [0] x1 + [0] Finally we apply the subprocessor We apply the weight gap principle, strictly orienting the rules {active^#(s(X)) -> c_7(s^#(active(X)))} and weakly orienting the rules { cons(ok(X1), ok(X2)) -> ok(cons(X1, X2)) , and(ok(X1), ok(X2)) -> ok(and(X1, X2))} using the following strongly linear interpretation: Processor 'Matrix Interpretation' oriented the following rules strictly: {active^#(s(X)) -> c_7(s^#(active(X)))} Details: Interpretation Functions: active(x1) = [1] x1 + [1] zeros() = [0] mark(x1) = [1] x1 + [1] cons(x1, x2) = [1] x1 + [1] x2 + [0] 0() = [0] and(x1, x2) = [1] x1 + [1] x2 + [0] tt() = [0] length(x1) = [1] x1 + [0] nil() = [0] s(x1) = [1] x1 + [4] proper(x1) = [0] x1 + [0] ok(x1) = [1] x1 + [0] top(x1) = [0] x1 + [0] active^#(x1) = [1] x1 + [1] c_0(x1) = [0] x1 + [0] cons^#(x1, x2) = [0] x1 + [0] x2 + [0] c_1() = [0] c_2() = [0] c_3(x1) = [0] x1 + [0] s^#(x1) = [1] x1 + [0] c_4(x1) = [0] x1 + [0] c_5(x1) = [0] x1 + [0] and^#(x1, x2) = [0] x1 + [0] x2 + [0] c_6(x1) = [0] x1 + [0] length^#(x1) = [0] x1 + [0] c_7(x1) = [1] x1 + [0] c_8(x1) = [0] x1 + [0] c_9(x1) = [0] x1 + [0] c_10(x1) = [0] x1 + [0] c_11(x1) = [0] x1 + [0] proper^#(x1) = [0] x1 + [0] c_12() = [0] c_13(x1) = [0] x1 + [0] c_14() = [0] c_15(x1) = [0] x1 + [0] c_16() = [0] c_17(x1) = [0] x1 + [0] c_18() = [0] c_19(x1) = [0] x1 + [0] c_20(x1) = [0] x1 + [0] c_21(x1) = [0] x1 + [0] c_22(x1) = [0] x1 + [0] c_23(x1) = [0] x1 + [0] top^#(x1) = [0] x1 + [0] c_24(x1) = [0] x1 + [0] c_25(x1) = [0] x1 + [0] Finally we apply the subprocessor We apply the weight gap principle, strictly orienting the rules {active(length(nil())) -> mark(0())} and weakly orienting the rules { active^#(s(X)) -> c_7(s^#(active(X))) , cons(ok(X1), ok(X2)) -> ok(cons(X1, X2)) , and(ok(X1), ok(X2)) -> ok(and(X1, X2))} using the following strongly linear interpretation: Processor 'Matrix Interpretation' oriented the following rules strictly: {active(length(nil())) -> mark(0())} Details: Interpretation Functions: active(x1) = [1] x1 + [1] zeros() = [0] mark(x1) = [1] x1 + [1] cons(x1, x2) = [1] x1 + [1] x2 + [0] 0() = [0] and(x1, x2) = [1] x1 + [1] x2 + [0] tt() = [0] length(x1) = [1] x1 + [8] nil() = [0] s(x1) = [1] x1 + [0] proper(x1) = [0] x1 + [0] ok(x1) = [1] x1 + [0] top(x1) = [0] x1 + [0] active^#(x1) = [1] x1 + [9] c_0(x1) = [0] x1 + [0] cons^#(x1, x2) = [0] x1 + [0] x2 + [0] c_1() = [0] c_2() = [0] c_3(x1) = [0] x1 + [0] s^#(x1) = [1] x1 + [1] c_4(x1) = [0] x1 + [0] c_5(x1) = [0] x1 + [0] and^#(x1, x2) = [0] x1 + [0] x2 + [0] c_6(x1) = [0] x1 + [0] length^#(x1) = [0] x1 + [0] c_7(x1) = [1] x1 + [1] c_8(x1) = [0] x1 + [0] c_9(x1) = [0] x1 + [0] c_10(x1) = [0] x1 + [0] c_11(x1) = [0] x1 + [0] proper^#(x1) = [0] x1 + [0] c_12() = [0] c_13(x1) = [0] x1 + [0] c_14() = [0] c_15(x1) = [0] x1 + [0] c_16() = [0] c_17(x1) = [0] x1 + [0] c_18() = [0] c_19(x1) = [0] x1 + [0] c_20(x1) = [0] x1 + [0] c_21(x1) = [0] x1 + [0] c_22(x1) = [0] x1 + [0] c_23(x1) = [0] x1 + [0] top^#(x1) = [0] x1 + [0] c_24(x1) = [0] x1 + [0] c_25(x1) = [0] x1 + [0] Finally we apply the subprocessor We apply the weight gap principle, strictly orienting the rules { active(and(tt(), X)) -> mark(X) , active(length(cons(N, L))) -> mark(s(length(L)))} and weakly orienting the rules { active(length(nil())) -> mark(0()) , active^#(s(X)) -> c_7(s^#(active(X))) , cons(ok(X1), ok(X2)) -> ok(cons(X1, X2)) , and(ok(X1), ok(X2)) -> ok(and(X1, X2))} using the following strongly linear interpretation: Processor 'Matrix Interpretation' oriented the following rules strictly: { active(and(tt(), X)) -> mark(X) , active(length(cons(N, L))) -> mark(s(length(L)))} Details: Interpretation Functions: active(x1) = [1] x1 + [0] zeros() = [2] mark(x1) = [1] x1 + [0] cons(x1, x2) = [1] x1 + [1] x2 + [10] 0() = [11] and(x1, x2) = [1] x1 + [1] x2 + [0] tt() = [1] length(x1) = [1] x1 + [2] nil() = [9] s(x1) = [1] x1 + [0] proper(x1) = [0] x1 + [0] ok(x1) = [1] x1 + [0] top(x1) = [0] x1 + [0] active^#(x1) = [1] x1 + [9] c_0(x1) = [0] x1 + [0] cons^#(x1, x2) = [0] x1 + [0] x2 + [0] c_1() = [0] c_2() = [0] c_3(x1) = [0] x1 + [0] s^#(x1) = [1] x1 + [1] c_4(x1) = [0] x1 + [0] c_5(x1) = [0] x1 + [0] and^#(x1, x2) = [0] x1 + [0] x2 + [0] c_6(x1) = [0] x1 + [0] length^#(x1) = [0] x1 + [0] c_7(x1) = [1] x1 + [3] c_8(x1) = [0] x1 + [0] c_9(x1) = [0] x1 + [0] c_10(x1) = [0] x1 + [0] c_11(x1) = [0] x1 + [0] proper^#(x1) = [0] x1 + [0] c_12() = [0] c_13(x1) = [0] x1 + [0] c_14() = [0] c_15(x1) = [0] x1 + [0] c_16() = [0] c_17(x1) = [0] x1 + [0] c_18() = [0] c_19(x1) = [0] x1 + [0] c_20(x1) = [0] x1 + [0] c_21(x1) = [0] x1 + [0] c_22(x1) = [0] x1 + [0] c_23(x1) = [0] x1 + [0] top^#(x1) = [0] x1 + [0] c_24(x1) = [0] x1 + [0] c_25(x1) = [0] x1 + [0] Finally we apply the subprocessor We apply the weight gap principle, strictly orienting the rules {active(zeros()) -> mark(cons(0(), zeros()))} and weakly orienting the rules { active(and(tt(), X)) -> mark(X) , active(length(cons(N, L))) -> mark(s(length(L))) , active(length(nil())) -> mark(0()) , active^#(s(X)) -> c_7(s^#(active(X))) , cons(ok(X1), ok(X2)) -> ok(cons(X1, X2)) , and(ok(X1), ok(X2)) -> ok(and(X1, X2))} using the following strongly linear interpretation: Processor 'Matrix Interpretation' oriented the following rules strictly: {active(zeros()) -> mark(cons(0(), zeros()))} Details: Interpretation Functions: active(x1) = [1] x1 + [1] zeros() = [0] mark(x1) = [1] x1 + [0] cons(x1, x2) = [1] x1 + [1] x2 + [0] 0() = [0] and(x1, x2) = [1] x1 + [1] x2 + [0] tt() = [0] length(x1) = [1] x1 + [0] nil() = [12] s(x1) = [1] x1 + [0] proper(x1) = [0] x1 + [0] ok(x1) = [1] x1 + [0] top(x1) = [0] x1 + [0] active^#(x1) = [1] x1 + [9] c_0(x1) = [0] x1 + [0] cons^#(x1, x2) = [0] x1 + [0] x2 + [0] c_1() = [0] c_2() = [0] c_3(x1) = [0] x1 + [0] s^#(x1) = [1] x1 + [0] c_4(x1) = [0] x1 + [0] c_5(x1) = [0] x1 + [0] and^#(x1, x2) = [0] x1 + [0] x2 + [0] c_6(x1) = [0] x1 + [0] length^#(x1) = [0] x1 + [0] c_7(x1) = [1] x1 + [0] c_8(x1) = [0] x1 + [0] c_9(x1) = [0] x1 + [0] c_10(x1) = [0] x1 + [0] c_11(x1) = [0] x1 + [0] proper^#(x1) = [0] x1 + [0] c_12() = [0] c_13(x1) = [0] x1 + [0] c_14() = [0] c_15(x1) = [0] x1 + [0] c_16() = [0] c_17(x1) = [0] x1 + [0] c_18() = [0] c_19(x1) = [0] x1 + [0] c_20(x1) = [0] x1 + [0] c_21(x1) = [0] x1 + [0] c_22(x1) = [0] x1 + [0] c_23(x1) = [0] x1 + [0] top^#(x1) = [0] x1 + [0] c_24(x1) = [0] x1 + [0] c_25(x1) = [0] x1 + [0] Finally we apply the subprocessor 'fastest of 'combine', 'Bounds with default enrichment', 'Bounds with default enrichment'' ------------------------------------------------------------------------------------------ Answer: YES(?,O(n^1)) Input Problem: innermost relative runtime-complexity with respect to Strict Rules: { active(cons(X1, X2)) -> cons(active(X1), X2) , active(and(X1, X2)) -> and(active(X1), X2) , active(length(X)) -> length(active(X)) , active(s(X)) -> s(active(X)) , length(mark(X)) -> mark(length(X)) , length(ok(X)) -> ok(length(X)) , cons(mark(X1), X2) -> mark(cons(X1, X2)) , and(mark(X1), X2) -> mark(and(X1, X2)) , s(mark(X)) -> mark(s(X)) , s(ok(X)) -> ok(s(X))} Weak Rules: { active(zeros()) -> mark(cons(0(), zeros())) , active(and(tt(), X)) -> mark(X) , active(length(cons(N, L))) -> mark(s(length(L))) , active(length(nil())) -> mark(0()) , active^#(s(X)) -> c_7(s^#(active(X))) , cons(ok(X1), ok(X2)) -> ok(cons(X1, X2)) , and(ok(X1), ok(X2)) -> ok(and(X1, X2))} Details: The problem was solved by processor 'Bounds with default enrichment': 'Bounds with default enrichment' -------------------------------- Answer: YES(?,O(n^1)) Input Problem: innermost relative runtime-complexity with respect to Strict Rules: { active(cons(X1, X2)) -> cons(active(X1), X2) , active(and(X1, X2)) -> and(active(X1), X2) , active(length(X)) -> length(active(X)) , active(s(X)) -> s(active(X)) , length(mark(X)) -> mark(length(X)) , length(ok(X)) -> ok(length(X)) , cons(mark(X1), X2) -> mark(cons(X1, X2)) , and(mark(X1), X2) -> mark(and(X1, X2)) , s(mark(X)) -> mark(s(X)) , s(ok(X)) -> ok(s(X))} Weak Rules: { active(zeros()) -> mark(cons(0(), zeros())) , active(and(tt(), X)) -> mark(X) , active(length(cons(N, L))) -> mark(s(length(L))) , active(length(nil())) -> mark(0()) , active^#(s(X)) -> c_7(s^#(active(X))) , cons(ok(X1), ok(X2)) -> ok(cons(X1, X2)) , and(ok(X1), ok(X2)) -> ok(and(X1, X2))} Details: The problem is Match-bounded by 0. The enriched problem is compatible with the following automaton: { zeros_0() -> 2 , mark_0(2) -> 3 , mark_0(3) -> 3 , mark_0(5) -> 3 , mark_0(7) -> 3 , mark_0(9) -> 3 , mark_0(12) -> 3 , 0_0() -> 5 , tt_0() -> 7 , nil_0() -> 9 , ok_0(2) -> 12 , ok_0(3) -> 12 , ok_0(5) -> 12 , ok_0(7) -> 12 , ok_0(9) -> 12 , ok_0(12) -> 12 , active^#_0(2) -> 14 , active^#_0(3) -> 14 , active^#_0(5) -> 14 , active^#_0(7) -> 14 , active^#_0(9) -> 14 , active^#_0(12) -> 14 , s^#_0(2) -> 20 , s^#_0(3) -> 20 , s^#_0(5) -> 20 , s^#_0(7) -> 20 , s^#_0(9) -> 20 , s^#_0(12) -> 20} 10) {active^#(and(X1, X2)) -> c_5(and^#(active(X1), X2))} The usable rules for this path are the following: { active(zeros()) -> mark(cons(0(), zeros())) , active(and(tt(), X)) -> mark(X) , active(length(nil())) -> mark(0()) , active(length(cons(N, L))) -> mark(s(length(L))) , active(cons(X1, X2)) -> cons(active(X1), X2) , active(and(X1, X2)) -> and(active(X1), X2) , active(length(X)) -> length(active(X)) , active(s(X)) -> s(active(X)) , length(mark(X)) -> mark(length(X)) , length(ok(X)) -> ok(length(X)) , cons(mark(X1), X2) -> mark(cons(X1, X2)) , and(mark(X1), X2) -> mark(and(X1, X2)) , s(mark(X)) -> mark(s(X)) , cons(ok(X1), ok(X2)) -> ok(cons(X1, X2)) , and(ok(X1), ok(X2)) -> ok(and(X1, X2)) , s(ok(X)) -> ok(s(X))} We have applied the subprocessor on the union of usable rules and weak (innermost) dependency pairs. 'Weight Gap Principle' ---------------------- Answer: YES(?,O(n^1)) Input Problem: innermost runtime-complexity with respect to Rules: { active(zeros()) -> mark(cons(0(), zeros())) , active(and(tt(), X)) -> mark(X) , active(length(nil())) -> mark(0()) , active(length(cons(N, L))) -> mark(s(length(L))) , active(cons(X1, X2)) -> cons(active(X1), X2) , active(and(X1, X2)) -> and(active(X1), X2) , active(length(X)) -> length(active(X)) , active(s(X)) -> s(active(X)) , length(mark(X)) -> mark(length(X)) , length(ok(X)) -> ok(length(X)) , cons(mark(X1), X2) -> mark(cons(X1, X2)) , and(mark(X1), X2) -> mark(and(X1, X2)) , s(mark(X)) -> mark(s(X)) , cons(ok(X1), ok(X2)) -> ok(cons(X1, X2)) , and(ok(X1), ok(X2)) -> ok(and(X1, X2)) , s(ok(X)) -> ok(s(X)) , active^#(and(X1, X2)) -> c_5(and^#(active(X1), X2))} Details: We apply the weight gap principle, strictly orienting the rules {active^#(and(X1, X2)) -> c_5(and^#(active(X1), X2))} and weakly orienting the rules {} using the following strongly linear interpretation: Processor 'Matrix Interpretation' oriented the following rules strictly: {active^#(and(X1, X2)) -> c_5(and^#(active(X1), X2))} Details: Interpretation Functions: active(x1) = [1] x1 + [1] zeros() = [0] mark(x1) = [1] x1 + [1] cons(x1, x2) = [1] x1 + [1] x2 + [0] 0() = [0] and(x1, x2) = [1] x1 + [1] x2 + [0] tt() = [0] length(x1) = [1] x1 + [0] nil() = [0] s(x1) = [1] x1 + [0] proper(x1) = [0] x1 + [0] ok(x1) = [1] x1 + [0] top(x1) = [0] x1 + [0] active^#(x1) = [1] x1 + [9] c_0(x1) = [0] x1 + [0] cons^#(x1, x2) = [0] x1 + [0] x2 + [0] c_1() = [0] c_2() = [0] c_3(x1) = [0] x1 + [0] s^#(x1) = [0] x1 + [0] c_4(x1) = [0] x1 + [0] c_5(x1) = [1] x1 + [1] and^#(x1, x2) = [1] x1 + [1] x2 + [1] c_6(x1) = [0] x1 + [0] length^#(x1) = [0] x1 + [0] c_7(x1) = [0] x1 + [0] c_8(x1) = [0] x1 + [0] c_9(x1) = [0] x1 + [0] c_10(x1) = [0] x1 + [0] c_11(x1) = [0] x1 + [0] proper^#(x1) = [0] x1 + [0] c_12() = [0] c_13(x1) = [0] x1 + [0] c_14() = [0] c_15(x1) = [0] x1 + [0] c_16() = [0] c_17(x1) = [0] x1 + [0] c_18() = [0] c_19(x1) = [0] x1 + [0] c_20(x1) = [0] x1 + [0] c_21(x1) = [0] x1 + [0] c_22(x1) = [0] x1 + [0] c_23(x1) = [0] x1 + [0] top^#(x1) = [0] x1 + [0] c_24(x1) = [0] x1 + [0] c_25(x1) = [0] x1 + [0] Finally we apply the subprocessor We apply the weight gap principle, strictly orienting the rules { cons(ok(X1), ok(X2)) -> ok(cons(X1, X2)) , and(ok(X1), ok(X2)) -> ok(and(X1, X2))} and weakly orienting the rules {active^#(and(X1, X2)) -> c_5(and^#(active(X1), X2))} using the following strongly linear interpretation: Processor 'Matrix Interpretation' oriented the following rules strictly: { cons(ok(X1), ok(X2)) -> ok(cons(X1, X2)) , and(ok(X1), ok(X2)) -> ok(and(X1, X2))} Details: Interpretation Functions: active(x1) = [1] x1 + [1] zeros() = [0] mark(x1) = [1] x1 + [1] cons(x1, x2) = [1] x1 + [1] x2 + [0] 0() = [0] and(x1, x2) = [1] x1 + [1] x2 + [0] tt() = [0] length(x1) = [1] x1 + [0] nil() = [0] s(x1) = [1] x1 + [0] proper(x1) = [0] x1 + [0] ok(x1) = [1] x1 + [8] top(x1) = [0] x1 + [0] active^#(x1) = [1] x1 + [11] c_0(x1) = [0] x1 + [0] cons^#(x1, x2) = [0] x1 + [0] x2 + [0] c_1() = [0] c_2() = [0] c_3(x1) = [0] x1 + [0] s^#(x1) = [0] x1 + [0] c_4(x1) = [0] x1 + [0] c_5(x1) = [1] x1 + [1] and^#(x1, x2) = [1] x1 + [1] x2 + [7] c_6(x1) = [0] x1 + [0] length^#(x1) = [0] x1 + [0] c_7(x1) = [0] x1 + [0] c_8(x1) = [0] x1 + [0] c_9(x1) = [0] x1 + [0] c_10(x1) = [0] x1 + [0] c_11(x1) = [0] x1 + [0] proper^#(x1) = [0] x1 + [0] c_12() = [0] c_13(x1) = [0] x1 + [0] c_14() = [0] c_15(x1) = [0] x1 + [0] c_16() = [0] c_17(x1) = [0] x1 + [0] c_18() = [0] c_19(x1) = [0] x1 + [0] c_20(x1) = [0] x1 + [0] c_21(x1) = [0] x1 + [0] c_22(x1) = [0] x1 + [0] c_23(x1) = [0] x1 + [0] top^#(x1) = [0] x1 + [0] c_24(x1) = [0] x1 + [0] c_25(x1) = [0] x1 + [0] Finally we apply the subprocessor We apply the weight gap principle, strictly orienting the rules {active(length(nil())) -> mark(0())} and weakly orienting the rules { cons(ok(X1), ok(X2)) -> ok(cons(X1, X2)) , and(ok(X1), ok(X2)) -> ok(and(X1, X2)) , active^#(and(X1, X2)) -> c_5(and^#(active(X1), X2))} using the following strongly linear interpretation: Processor 'Matrix Interpretation' oriented the following rules strictly: {active(length(nil())) -> mark(0())} Details: Interpretation Functions: active(x1) = [1] x1 + [1] zeros() = [0] mark(x1) = [1] x1 + [1] cons(x1, x2) = [1] x1 + [1] x2 + [0] 0() = [0] and(x1, x2) = [1] x1 + [1] x2 + [0] tt() = [0] length(x1) = [1] x1 + [8] nil() = [0] s(x1) = [1] x1 + [0] proper(x1) = [0] x1 + [0] ok(x1) = [1] x1 + [0] top(x1) = [0] x1 + [0] active^#(x1) = [1] x1 + [1] c_0(x1) = [0] x1 + [0] cons^#(x1, x2) = [0] x1 + [0] x2 + [0] c_1() = [0] c_2() = [0] c_3(x1) = [0] x1 + [0] s^#(x1) = [0] x1 + [0] c_4(x1) = [0] x1 + [0] c_5(x1) = [1] x1 + [0] and^#(x1, x2) = [1] x1 + [1] x2 + [0] c_6(x1) = [0] x1 + [0] length^#(x1) = [0] x1 + [0] c_7(x1) = [0] x1 + [0] c_8(x1) = [0] x1 + [0] c_9(x1) = [0] x1 + [0] c_10(x1) = [0] x1 + [0] c_11(x1) = [0] x1 + [0] proper^#(x1) = [0] x1 + [0] c_12() = [0] c_13(x1) = [0] x1 + [0] c_14() = [0] c_15(x1) = [0] x1 + [0] c_16() = [0] c_17(x1) = [0] x1 + [0] c_18() = [0] c_19(x1) = [0] x1 + [0] c_20(x1) = [0] x1 + [0] c_21(x1) = [0] x1 + [0] c_22(x1) = [0] x1 + [0] c_23(x1) = [0] x1 + [0] top^#(x1) = [0] x1 + [0] c_24(x1) = [0] x1 + [0] c_25(x1) = [0] x1 + [0] Finally we apply the subprocessor We apply the weight gap principle, strictly orienting the rules { active(and(tt(), X)) -> mark(X) , active(length(cons(N, L))) -> mark(s(length(L)))} and weakly orienting the rules { active(length(nil())) -> mark(0()) , cons(ok(X1), ok(X2)) -> ok(cons(X1, X2)) , and(ok(X1), ok(X2)) -> ok(and(X1, X2)) , active^#(and(X1, X2)) -> c_5(and^#(active(X1), X2))} using the following strongly linear interpretation: Processor 'Matrix Interpretation' oriented the following rules strictly: { active(and(tt(), X)) -> mark(X) , active(length(cons(N, L))) -> mark(s(length(L)))} Details: Interpretation Functions: active(x1) = [1] x1 + [0] zeros() = [0] mark(x1) = [1] x1 + [0] cons(x1, x2) = [1] x1 + [1] x2 + [6] 0() = [1] and(x1, x2) = [1] x1 + [1] x2 + [1] tt() = [1] length(x1) = [1] x1 + [0] nil() = [8] s(x1) = [1] x1 + [0] proper(x1) = [0] x1 + [0] ok(x1) = [1] x1 + [0] top(x1) = [0] x1 + [0] active^#(x1) = [1] x1 + [15] c_0(x1) = [0] x1 + [0] cons^#(x1, x2) = [0] x1 + [0] x2 + [0] c_1() = [0] c_2() = [0] c_3(x1) = [0] x1 + [0] s^#(x1) = [0] x1 + [0] c_4(x1) = [0] x1 + [0] c_5(x1) = [1] x1 + [5] and^#(x1, x2) = [1] x1 + [1] x2 + [0] c_6(x1) = [0] x1 + [0] length^#(x1) = [0] x1 + [0] c_7(x1) = [0] x1 + [0] c_8(x1) = [0] x1 + [0] c_9(x1) = [0] x1 + [0] c_10(x1) = [0] x1 + [0] c_11(x1) = [0] x1 + [0] proper^#(x1) = [0] x1 + [0] c_12() = [0] c_13(x1) = [0] x1 + [0] c_14() = [0] c_15(x1) = [0] x1 + [0] c_16() = [0] c_17(x1) = [0] x1 + [0] c_18() = [0] c_19(x1) = [0] x1 + [0] c_20(x1) = [0] x1 + [0] c_21(x1) = [0] x1 + [0] c_22(x1) = [0] x1 + [0] c_23(x1) = [0] x1 + [0] top^#(x1) = [0] x1 + [0] c_24(x1) = [0] x1 + [0] c_25(x1) = [0] x1 + [0] Finally we apply the subprocessor We apply the weight gap principle, strictly orienting the rules {active(zeros()) -> mark(cons(0(), zeros()))} and weakly orienting the rules { active(and(tt(), X)) -> mark(X) , active(length(cons(N, L))) -> mark(s(length(L))) , active(length(nil())) -> mark(0()) , cons(ok(X1), ok(X2)) -> ok(cons(X1, X2)) , and(ok(X1), ok(X2)) -> ok(and(X1, X2)) , active^#(and(X1, X2)) -> c_5(and^#(active(X1), X2))} using the following strongly linear interpretation: Processor 'Matrix Interpretation' oriented the following rules strictly: {active(zeros()) -> mark(cons(0(), zeros()))} Details: Interpretation Functions: active(x1) = [1] x1 + [2] zeros() = [1] mark(x1) = [1] x1 + [0] cons(x1, x2) = [1] x1 + [1] x2 + [0] 0() = [1] and(x1, x2) = [1] x1 + [1] x2 + [0] tt() = [8] length(x1) = [1] x1 + [0] nil() = [15] s(x1) = [1] x1 + [0] proper(x1) = [0] x1 + [0] ok(x1) = [1] x1 + [0] top(x1) = [0] x1 + [0] active^#(x1) = [1] x1 + [5] c_0(x1) = [0] x1 + [0] cons^#(x1, x2) = [0] x1 + [0] x2 + [0] c_1() = [0] c_2() = [0] c_3(x1) = [0] x1 + [0] s^#(x1) = [0] x1 + [0] c_4(x1) = [0] x1 + [0] c_5(x1) = [1] x1 + [0] and^#(x1, x2) = [1] x1 + [1] x2 + [0] c_6(x1) = [0] x1 + [0] length^#(x1) = [0] x1 + [0] c_7(x1) = [0] x1 + [0] c_8(x1) = [0] x1 + [0] c_9(x1) = [0] x1 + [0] c_10(x1) = [0] x1 + [0] c_11(x1) = [0] x1 + [0] proper^#(x1) = [0] x1 + [0] c_12() = [0] c_13(x1) = [0] x1 + [0] c_14() = [0] c_15(x1) = [0] x1 + [0] c_16() = [0] c_17(x1) = [0] x1 + [0] c_18() = [0] c_19(x1) = [0] x1 + [0] c_20(x1) = [0] x1 + [0] c_21(x1) = [0] x1 + [0] c_22(x1) = [0] x1 + [0] c_23(x1) = [0] x1 + [0] top^#(x1) = [0] x1 + [0] c_24(x1) = [0] x1 + [0] c_25(x1) = [0] x1 + [0] Finally we apply the subprocessor 'fastest of 'combine', 'Bounds with default enrichment', 'Bounds with default enrichment'' ------------------------------------------------------------------------------------------ Answer: YES(?,O(n^1)) Input Problem: innermost relative runtime-complexity with respect to Strict Rules: { active(cons(X1, X2)) -> cons(active(X1), X2) , active(and(X1, X2)) -> and(active(X1), X2) , active(length(X)) -> length(active(X)) , active(s(X)) -> s(active(X)) , length(mark(X)) -> mark(length(X)) , length(ok(X)) -> ok(length(X)) , cons(mark(X1), X2) -> mark(cons(X1, X2)) , and(mark(X1), X2) -> mark(and(X1, X2)) , s(mark(X)) -> mark(s(X)) , s(ok(X)) -> ok(s(X))} Weak Rules: { active(zeros()) -> mark(cons(0(), zeros())) , active(and(tt(), X)) -> mark(X) , active(length(cons(N, L))) -> mark(s(length(L))) , active(length(nil())) -> mark(0()) , cons(ok(X1), ok(X2)) -> ok(cons(X1, X2)) , and(ok(X1), ok(X2)) -> ok(and(X1, X2)) , active^#(and(X1, X2)) -> c_5(and^#(active(X1), X2))} Details: The problem was solved by processor 'Bounds with default enrichment': 'Bounds with default enrichment' -------------------------------- Answer: YES(?,O(n^1)) Input Problem: innermost relative runtime-complexity with respect to Strict Rules: { active(cons(X1, X2)) -> cons(active(X1), X2) , active(and(X1, X2)) -> and(active(X1), X2) , active(length(X)) -> length(active(X)) , active(s(X)) -> s(active(X)) , length(mark(X)) -> mark(length(X)) , length(ok(X)) -> ok(length(X)) , cons(mark(X1), X2) -> mark(cons(X1, X2)) , and(mark(X1), X2) -> mark(and(X1, X2)) , s(mark(X)) -> mark(s(X)) , s(ok(X)) -> ok(s(X))} Weak Rules: { active(zeros()) -> mark(cons(0(), zeros())) , active(and(tt(), X)) -> mark(X) , active(length(cons(N, L))) -> mark(s(length(L))) , active(length(nil())) -> mark(0()) , cons(ok(X1), ok(X2)) -> ok(cons(X1, X2)) , and(ok(X1), ok(X2)) -> ok(and(X1, X2)) , active^#(and(X1, X2)) -> c_5(and^#(active(X1), X2))} Details: The problem is Match-bounded by 0. The enriched problem is compatible with the following automaton: { zeros_0() -> 2 , mark_0(2) -> 3 , mark_0(3) -> 3 , mark_0(5) -> 3 , mark_0(7) -> 3 , mark_0(9) -> 3 , mark_0(12) -> 3 , 0_0() -> 5 , tt_0() -> 7 , nil_0() -> 9 , ok_0(2) -> 12 , ok_0(3) -> 12 , ok_0(5) -> 12 , ok_0(7) -> 12 , ok_0(9) -> 12 , ok_0(12) -> 12 , active^#_0(2) -> 14 , active^#_0(3) -> 14 , active^#_0(5) -> 14 , active^#_0(7) -> 14 , active^#_0(9) -> 14 , active^#_0(12) -> 14 , and^#_0(2, 2) -> 23 , and^#_0(2, 3) -> 23 , and^#_0(2, 5) -> 23 , and^#_0(2, 7) -> 23 , and^#_0(2, 9) -> 23 , and^#_0(2, 12) -> 23 , and^#_0(3, 2) -> 23 , and^#_0(3, 3) -> 23 , and^#_0(3, 5) -> 23 , and^#_0(3, 7) -> 23 , and^#_0(3, 9) -> 23 , and^#_0(3, 12) -> 23 , and^#_0(5, 2) -> 23 , and^#_0(5, 3) -> 23 , and^#_0(5, 5) -> 23 , and^#_0(5, 7) -> 23 , and^#_0(5, 9) -> 23 , and^#_0(5, 12) -> 23 , and^#_0(7, 2) -> 23 , and^#_0(7, 3) -> 23 , and^#_0(7, 5) -> 23 , and^#_0(7, 7) -> 23 , and^#_0(7, 9) -> 23 , and^#_0(7, 12) -> 23 , and^#_0(9, 2) -> 23 , and^#_0(9, 3) -> 23 , and^#_0(9, 5) -> 23 , and^#_0(9, 7) -> 23 , and^#_0(9, 9) -> 23 , and^#_0(9, 12) -> 23 , and^#_0(12, 2) -> 23 , and^#_0(12, 3) -> 23 , and^#_0(12, 5) -> 23 , and^#_0(12, 7) -> 23 , and^#_0(12, 9) -> 23 , and^#_0(12, 12) -> 23} 11) {active^#(length(X)) -> c_6(length^#(active(X)))} The usable rules for this path are the following: { active(zeros()) -> mark(cons(0(), zeros())) , active(and(tt(), X)) -> mark(X) , active(length(nil())) -> mark(0()) , active(length(cons(N, L))) -> mark(s(length(L))) , active(cons(X1, X2)) -> cons(active(X1), X2) , active(and(X1, X2)) -> and(active(X1), X2) , active(length(X)) -> length(active(X)) , active(s(X)) -> s(active(X)) , length(mark(X)) -> mark(length(X)) , length(ok(X)) -> ok(length(X)) , cons(mark(X1), X2) -> mark(cons(X1, X2)) , and(mark(X1), X2) -> mark(and(X1, X2)) , s(mark(X)) -> mark(s(X)) , cons(ok(X1), ok(X2)) -> ok(cons(X1, X2)) , and(ok(X1), ok(X2)) -> ok(and(X1, X2)) , s(ok(X)) -> ok(s(X))} We have applied the subprocessor on the union of usable rules and weak (innermost) dependency pairs. 'Weight Gap Principle' ---------------------- Answer: YES(?,O(n^1)) Input Problem: innermost runtime-complexity with respect to Rules: { active(zeros()) -> mark(cons(0(), zeros())) , active(and(tt(), X)) -> mark(X) , active(length(nil())) -> mark(0()) , active(length(cons(N, L))) -> mark(s(length(L))) , active(cons(X1, X2)) -> cons(active(X1), X2) , active(and(X1, X2)) -> and(active(X1), X2) , active(length(X)) -> length(active(X)) , active(s(X)) -> s(active(X)) , length(mark(X)) -> mark(length(X)) , length(ok(X)) -> ok(length(X)) , cons(mark(X1), X2) -> mark(cons(X1, X2)) , and(mark(X1), X2) -> mark(and(X1, X2)) , s(mark(X)) -> mark(s(X)) , cons(ok(X1), ok(X2)) -> ok(cons(X1, X2)) , and(ok(X1), ok(X2)) -> ok(and(X1, X2)) , s(ok(X)) -> ok(s(X)) , active^#(length(X)) -> c_6(length^#(active(X)))} Details: We apply the weight gap principle, strictly orienting the rules {active^#(length(X)) -> c_6(length^#(active(X)))} and weakly orienting the rules {} using the following strongly linear interpretation: Processor 'Matrix Interpretation' oriented the following rules strictly: {active^#(length(X)) -> c_6(length^#(active(X)))} Details: Interpretation Functions: active(x1) = [1] x1 + [1] zeros() = [0] mark(x1) = [1] x1 + [1] cons(x1, x2) = [1] x1 + [1] x2 + [0] 0() = [0] and(x1, x2) = [1] x1 + [1] x2 + [0] tt() = [0] length(x1) = [1] x1 + [0] nil() = [0] s(x1) = [1] x1 + [0] proper(x1) = [0] x1 + [0] ok(x1) = [1] x1 + [0] top(x1) = [0] x1 + [0] active^#(x1) = [1] x1 + [9] c_0(x1) = [0] x1 + [0] cons^#(x1, x2) = [0] x1 + [0] x2 + [0] c_1() = [0] c_2() = [0] c_3(x1) = [0] x1 + [0] s^#(x1) = [0] x1 + [0] c_4(x1) = [0] x1 + [0] c_5(x1) = [0] x1 + [0] and^#(x1, x2) = [0] x1 + [0] x2 + [0] c_6(x1) = [1] x1 + [1] length^#(x1) = [1] x1 + [1] c_7(x1) = [0] x1 + [0] c_8(x1) = [0] x1 + [0] c_9(x1) = [0] x1 + [0] c_10(x1) = [0] x1 + [0] c_11(x1) = [0] x1 + [0] proper^#(x1) = [0] x1 + [0] c_12() = [0] c_13(x1) = [0] x1 + [0] c_14() = [0] c_15(x1) = [0] x1 + [0] c_16() = [0] c_17(x1) = [0] x1 + [0] c_18() = [0] c_19(x1) = [0] x1 + [0] c_20(x1) = [0] x1 + [0] c_21(x1) = [0] x1 + [0] c_22(x1) = [0] x1 + [0] c_23(x1) = [0] x1 + [0] top^#(x1) = [0] x1 + [0] c_24(x1) = [0] x1 + [0] c_25(x1) = [0] x1 + [0] Finally we apply the subprocessor We apply the weight gap principle, strictly orienting the rules { cons(ok(X1), ok(X2)) -> ok(cons(X1, X2)) , and(ok(X1), ok(X2)) -> ok(and(X1, X2))} and weakly orienting the rules {active^#(length(X)) -> c_6(length^#(active(X)))} using the following strongly linear interpretation: Processor 'Matrix Interpretation' oriented the following rules strictly: { cons(ok(X1), ok(X2)) -> ok(cons(X1, X2)) , and(ok(X1), ok(X2)) -> ok(and(X1, X2))} Details: Interpretation Functions: active(x1) = [1] x1 + [1] zeros() = [0] mark(x1) = [1] x1 + [1] cons(x1, x2) = [1] x1 + [1] x2 + [0] 0() = [0] and(x1, x2) = [1] x1 + [1] x2 + [0] tt() = [0] length(x1) = [1] x1 + [0] nil() = [0] s(x1) = [1] x1 + [0] proper(x1) = [0] x1 + [0] ok(x1) = [1] x1 + [8] top(x1) = [0] x1 + [0] active^#(x1) = [1] x1 + [9] c_0(x1) = [0] x1 + [0] cons^#(x1, x2) = [0] x1 + [0] x2 + [0] c_1() = [0] c_2() = [0] c_3(x1) = [0] x1 + [0] s^#(x1) = [0] x1 + [0] c_4(x1) = [0] x1 + [0] c_5(x1) = [0] x1 + [0] and^#(x1, x2) = [0] x1 + [0] x2 + [0] c_6(x1) = [1] x1 + [1] length^#(x1) = [1] x1 + [1] c_7(x1) = [0] x1 + [0] c_8(x1) = [0] x1 + [0] c_9(x1) = [0] x1 + [0] c_10(x1) = [0] x1 + [0] c_11(x1) = [0] x1 + [0] proper^#(x1) = [0] x1 + [0] c_12() = [0] c_13(x1) = [0] x1 + [0] c_14() = [0] c_15(x1) = [0] x1 + [0] c_16() = [0] c_17(x1) = [0] x1 + [0] c_18() = [0] c_19(x1) = [0] x1 + [0] c_20(x1) = [0] x1 + [0] c_21(x1) = [0] x1 + [0] c_22(x1) = [0] x1 + [0] c_23(x1) = [0] x1 + [0] top^#(x1) = [0] x1 + [0] c_24(x1) = [0] x1 + [0] c_25(x1) = [0] x1 + [0] Finally we apply the subprocessor We apply the weight gap principle, strictly orienting the rules {active(length(nil())) -> mark(0())} and weakly orienting the rules { cons(ok(X1), ok(X2)) -> ok(cons(X1, X2)) , and(ok(X1), ok(X2)) -> ok(and(X1, X2)) , active^#(length(X)) -> c_6(length^#(active(X)))} using the following strongly linear interpretation: Processor 'Matrix Interpretation' oriented the following rules strictly: {active(length(nil())) -> mark(0())} Details: Interpretation Functions: active(x1) = [1] x1 + [1] zeros() = [0] mark(x1) = [1] x1 + [1] cons(x1, x2) = [1] x1 + [1] x2 + [0] 0() = [0] and(x1, x2) = [1] x1 + [1] x2 + [0] tt() = [0] length(x1) = [1] x1 + [0] nil() = [8] s(x1) = [1] x1 + [0] proper(x1) = [0] x1 + [0] ok(x1) = [1] x1 + [1] top(x1) = [0] x1 + [0] active^#(x1) = [1] x1 + [13] c_0(x1) = [0] x1 + [0] cons^#(x1, x2) = [0] x1 + [0] x2 + [0] c_1() = [0] c_2() = [0] c_3(x1) = [0] x1 + [0] s^#(x1) = [0] x1 + [0] c_4(x1) = [0] x1 + [0] c_5(x1) = [0] x1 + [0] and^#(x1, x2) = [0] x1 + [0] x2 + [0] c_6(x1) = [1] x1 + [0] length^#(x1) = [1] x1 + [11] c_7(x1) = [0] x1 + [0] c_8(x1) = [0] x1 + [0] c_9(x1) = [0] x1 + [0] c_10(x1) = [0] x1 + [0] c_11(x1) = [0] x1 + [0] proper^#(x1) = [0] x1 + [0] c_12() = [0] c_13(x1) = [0] x1 + [0] c_14() = [0] c_15(x1) = [0] x1 + [0] c_16() = [0] c_17(x1) = [0] x1 + [0] c_18() = [0] c_19(x1) = [0] x1 + [0] c_20(x1) = [0] x1 + [0] c_21(x1) = [0] x1 + [0] c_22(x1) = [0] x1 + [0] c_23(x1) = [0] x1 + [0] top^#(x1) = [0] x1 + [0] c_24(x1) = [0] x1 + [0] c_25(x1) = [0] x1 + [0] Finally we apply the subprocessor We apply the weight gap principle, strictly orienting the rules { active(and(tt(), X)) -> mark(X) , active(length(cons(N, L))) -> mark(s(length(L)))} and weakly orienting the rules { active(length(nil())) -> mark(0()) , cons(ok(X1), ok(X2)) -> ok(cons(X1, X2)) , and(ok(X1), ok(X2)) -> ok(and(X1, X2)) , active^#(length(X)) -> c_6(length^#(active(X)))} using the following strongly linear interpretation: Processor 'Matrix Interpretation' oriented the following rules strictly: { active(and(tt(), X)) -> mark(X) , active(length(cons(N, L))) -> mark(s(length(L)))} Details: Interpretation Functions: active(x1) = [1] x1 + [0] zeros() = [0] mark(x1) = [1] x1 + [0] cons(x1, x2) = [1] x1 + [1] x2 + [14] 0() = [1] and(x1, x2) = [1] x1 + [1] x2 + [0] tt() = [2] length(x1) = [1] x1 + [0] nil() = [2] s(x1) = [1] x1 + [0] proper(x1) = [0] x1 + [0] ok(x1) = [1] x1 + [0] top(x1) = [0] x1 + [0] active^#(x1) = [1] x1 + [4] c_0(x1) = [0] x1 + [0] cons^#(x1, x2) = [0] x1 + [0] x2 + [0] c_1() = [0] c_2() = [0] c_3(x1) = [0] x1 + [0] s^#(x1) = [0] x1 + [0] c_4(x1) = [0] x1 + [0] c_5(x1) = [0] x1 + [0] and^#(x1, x2) = [0] x1 + [0] x2 + [0] c_6(x1) = [1] x1 + [1] length^#(x1) = [1] x1 + [0] c_7(x1) = [0] x1 + [0] c_8(x1) = [0] x1 + [0] c_9(x1) = [0] x1 + [0] c_10(x1) = [0] x1 + [0] c_11(x1) = [0] x1 + [0] proper^#(x1) = [0] x1 + [0] c_12() = [0] c_13(x1) = [0] x1 + [0] c_14() = [0] c_15(x1) = [0] x1 + [0] c_16() = [0] c_17(x1) = [0] x1 + [0] c_18() = [0] c_19(x1) = [0] x1 + [0] c_20(x1) = [0] x1 + [0] c_21(x1) = [0] x1 + [0] c_22(x1) = [0] x1 + [0] c_23(x1) = [0] x1 + [0] top^#(x1) = [0] x1 + [0] c_24(x1) = [0] x1 + [0] c_25(x1) = [0] x1 + [0] Finally we apply the subprocessor We apply the weight gap principle, strictly orienting the rules {active(zeros()) -> mark(cons(0(), zeros()))} and weakly orienting the rules { active(and(tt(), X)) -> mark(X) , active(length(cons(N, L))) -> mark(s(length(L))) , active(length(nil())) -> mark(0()) , cons(ok(X1), ok(X2)) -> ok(cons(X1, X2)) , and(ok(X1), ok(X2)) -> ok(and(X1, X2)) , active^#(length(X)) -> c_6(length^#(active(X)))} using the following strongly linear interpretation: Processor 'Matrix Interpretation' oriented the following rules strictly: {active(zeros()) -> mark(cons(0(), zeros()))} Details: Interpretation Functions: active(x1) = [1] x1 + [1] zeros() = [7] mark(x1) = [1] x1 + [0] cons(x1, x2) = [1] x1 + [1] x2 + [0] 0() = [0] and(x1, x2) = [1] x1 + [1] x2 + [0] tt() = [0] length(x1) = [1] x1 + [4] nil() = [11] s(x1) = [1] x1 + [0] proper(x1) = [0] x1 + [0] ok(x1) = [1] x1 + [0] top(x1) = [0] x1 + [0] active^#(x1) = [1] x1 + [13] c_0(x1) = [0] x1 + [0] cons^#(x1, x2) = [0] x1 + [0] x2 + [0] c_1() = [0] c_2() = [0] c_3(x1) = [0] x1 + [0] s^#(x1) = [0] x1 + [0] c_4(x1) = [0] x1 + [0] c_5(x1) = [0] x1 + [0] and^#(x1, x2) = [0] x1 + [0] x2 + [0] c_6(x1) = [1] x1 + [4] length^#(x1) = [1] x1 + [12] c_7(x1) = [0] x1 + [0] c_8(x1) = [0] x1 + [0] c_9(x1) = [0] x1 + [0] c_10(x1) = [0] x1 + [0] c_11(x1) = [0] x1 + [0] proper^#(x1) = [0] x1 + [0] c_12() = [0] c_13(x1) = [0] x1 + [0] c_14() = [0] c_15(x1) = [0] x1 + [0] c_16() = [0] c_17(x1) = [0] x1 + [0] c_18() = [0] c_19(x1) = [0] x1 + [0] c_20(x1) = [0] x1 + [0] c_21(x1) = [0] x1 + [0] c_22(x1) = [0] x1 + [0] c_23(x1) = [0] x1 + [0] top^#(x1) = [0] x1 + [0] c_24(x1) = [0] x1 + [0] c_25(x1) = [0] x1 + [0] Finally we apply the subprocessor 'fastest of 'combine', 'Bounds with default enrichment', 'Bounds with default enrichment'' ------------------------------------------------------------------------------------------ Answer: YES(?,O(n^1)) Input Problem: innermost relative runtime-complexity with respect to Strict Rules: { active(cons(X1, X2)) -> cons(active(X1), X2) , active(and(X1, X2)) -> and(active(X1), X2) , active(length(X)) -> length(active(X)) , active(s(X)) -> s(active(X)) , length(mark(X)) -> mark(length(X)) , length(ok(X)) -> ok(length(X)) , cons(mark(X1), X2) -> mark(cons(X1, X2)) , and(mark(X1), X2) -> mark(and(X1, X2)) , s(mark(X)) -> mark(s(X)) , s(ok(X)) -> ok(s(X))} Weak Rules: { active(zeros()) -> mark(cons(0(), zeros())) , active(and(tt(), X)) -> mark(X) , active(length(cons(N, L))) -> mark(s(length(L))) , active(length(nil())) -> mark(0()) , cons(ok(X1), ok(X2)) -> ok(cons(X1, X2)) , and(ok(X1), ok(X2)) -> ok(and(X1, X2)) , active^#(length(X)) -> c_6(length^#(active(X)))} Details: The problem was solved by processor 'Bounds with default enrichment': 'Bounds with default enrichment' -------------------------------- Answer: YES(?,O(n^1)) Input Problem: innermost relative runtime-complexity with respect to Strict Rules: { active(cons(X1, X2)) -> cons(active(X1), X2) , active(and(X1, X2)) -> and(active(X1), X2) , active(length(X)) -> length(active(X)) , active(s(X)) -> s(active(X)) , length(mark(X)) -> mark(length(X)) , length(ok(X)) -> ok(length(X)) , cons(mark(X1), X2) -> mark(cons(X1, X2)) , and(mark(X1), X2) -> mark(and(X1, X2)) , s(mark(X)) -> mark(s(X)) , s(ok(X)) -> ok(s(X))} Weak Rules: { active(zeros()) -> mark(cons(0(), zeros())) , active(and(tt(), X)) -> mark(X) , active(length(cons(N, L))) -> mark(s(length(L))) , active(length(nil())) -> mark(0()) , cons(ok(X1), ok(X2)) -> ok(cons(X1, X2)) , and(ok(X1), ok(X2)) -> ok(and(X1, X2)) , active^#(length(X)) -> c_6(length^#(active(X)))} Details: The problem is Match-bounded by 0. The enriched problem is compatible with the following automaton: { zeros_0() -> 2 , mark_0(2) -> 3 , mark_0(3) -> 3 , mark_0(5) -> 3 , mark_0(7) -> 3 , mark_0(9) -> 3 , mark_0(12) -> 3 , 0_0() -> 5 , tt_0() -> 7 , nil_0() -> 9 , ok_0(2) -> 12 , ok_0(3) -> 12 , ok_0(5) -> 12 , ok_0(7) -> 12 , ok_0(9) -> 12 , ok_0(12) -> 12 , active^#_0(2) -> 14 , active^#_0(3) -> 14 , active^#_0(5) -> 14 , active^#_0(7) -> 14 , active^#_0(9) -> 14 , active^#_0(12) -> 14 , length^#_0(2) -> 25 , length^#_0(3) -> 25 , length^#_0(5) -> 25 , length^#_0(7) -> 25 , length^#_0(9) -> 25 , length^#_0(12) -> 25} 12) { proper^#(length(X)) -> c_17(length^#(proper(X))) , length^#(ok(X)) -> c_22(length^#(X)) , length^#(mark(X)) -> c_10(length^#(X))} The usable rules for this path are the following: { proper(zeros()) -> ok(zeros()) , proper(cons(X1, X2)) -> cons(proper(X1), proper(X2)) , proper(0()) -> ok(0()) , proper(and(X1, X2)) -> and(proper(X1), proper(X2)) , proper(tt()) -> ok(tt()) , proper(length(X)) -> length(proper(X)) , proper(nil()) -> ok(nil()) , proper(s(X)) -> s(proper(X)) , length(mark(X)) -> mark(length(X)) , length(ok(X)) -> ok(length(X)) , cons(mark(X1), X2) -> mark(cons(X1, X2)) , and(mark(X1), X2) -> mark(and(X1, X2)) , s(mark(X)) -> mark(s(X)) , cons(ok(X1), ok(X2)) -> ok(cons(X1, X2)) , and(ok(X1), ok(X2)) -> ok(and(X1, X2)) , s(ok(X)) -> ok(s(X))} We have applied the subprocessor on the union of usable rules and weak (innermost) dependency pairs. 'Weight Gap Principle' ---------------------- Answer: YES(?,O(n^1)) Input Problem: innermost runtime-complexity with respect to Rules: { proper(zeros()) -> ok(zeros()) , proper(cons(X1, X2)) -> cons(proper(X1), proper(X2)) , proper(0()) -> ok(0()) , proper(and(X1, X2)) -> and(proper(X1), proper(X2)) , proper(tt()) -> ok(tt()) , proper(length(X)) -> length(proper(X)) , proper(nil()) -> ok(nil()) , proper(s(X)) -> s(proper(X)) , length(mark(X)) -> mark(length(X)) , length(ok(X)) -> ok(length(X)) , cons(mark(X1), X2) -> mark(cons(X1, X2)) , and(mark(X1), X2) -> mark(and(X1, X2)) , s(mark(X)) -> mark(s(X)) , cons(ok(X1), ok(X2)) -> ok(cons(X1, X2)) , and(ok(X1), ok(X2)) -> ok(and(X1, X2)) , s(ok(X)) -> ok(s(X)) , proper^#(length(X)) -> c_17(length^#(proper(X))) , length^#(ok(X)) -> c_22(length^#(X)) , length^#(mark(X)) -> c_10(length^#(X))} Details: We apply the weight gap principle, strictly orienting the rules { cons(ok(X1), ok(X2)) -> ok(cons(X1, X2)) , and(ok(X1), ok(X2)) -> ok(and(X1, X2)) , length^#(ok(X)) -> c_22(length^#(X))} and weakly orienting the rules {} using the following strongly linear interpretation: Processor 'Matrix Interpretation' oriented the following rules strictly: { cons(ok(X1), ok(X2)) -> ok(cons(X1, X2)) , and(ok(X1), ok(X2)) -> ok(and(X1, X2)) , length^#(ok(X)) -> c_22(length^#(X))} Details: Interpretation Functions: active(x1) = [0] x1 + [0] zeros() = [0] mark(x1) = [1] x1 + [0] cons(x1, x2) = [1] x1 + [1] x2 + [0] 0() = [0] and(x1, x2) = [1] x1 + [1] x2 + [0] tt() = [0] length(x1) = [1] x1 + [0] nil() = [0] s(x1) = [1] x1 + [0] proper(x1) = [1] x1 + [1] ok(x1) = [1] x1 + [1] top(x1) = [0] x1 + [0] active^#(x1) = [0] x1 + [0] c_0(x1) = [0] x1 + [0] cons^#(x1, x2) = [0] x1 + [0] x2 + [0] c_1() = [0] c_2() = [0] c_3(x1) = [0] x1 + [0] s^#(x1) = [0] x1 + [0] c_4(x1) = [0] x1 + [0] c_5(x1) = [0] x1 + [0] and^#(x1, x2) = [0] x1 + [0] x2 + [0] c_6(x1) = [0] x1 + [0] length^#(x1) = [1] x1 + [3] c_7(x1) = [0] x1 + [0] c_8(x1) = [0] x1 + [0] c_9(x1) = [0] x1 + [0] c_10(x1) = [1] x1 + [0] c_11(x1) = [0] x1 + [0] proper^#(x1) = [1] x1 + [1] c_12() = [0] c_13(x1) = [0] x1 + [0] c_14() = [0] c_15(x1) = [0] x1 + [0] c_16() = [0] c_17(x1) = [1] x1 + [1] c_18() = [0] c_19(x1) = [0] x1 + [0] c_20(x1) = [0] x1 + [0] c_21(x1) = [0] x1 + [0] c_22(x1) = [1] x1 + [0] c_23(x1) = [0] x1 + [0] top^#(x1) = [0] x1 + [0] c_24(x1) = [0] x1 + [0] c_25(x1) = [0] x1 + [0] Finally we apply the subprocessor We apply the weight gap principle, strictly orienting the rules {proper^#(length(X)) -> c_17(length^#(proper(X)))} and weakly orienting the rules { cons(ok(X1), ok(X2)) -> ok(cons(X1, X2)) , and(ok(X1), ok(X2)) -> ok(and(X1, X2)) , length^#(ok(X)) -> c_22(length^#(X))} using the following strongly linear interpretation: Processor 'Matrix Interpretation' oriented the following rules strictly: {proper^#(length(X)) -> c_17(length^#(proper(X)))} Details: Interpretation Functions: active(x1) = [0] x1 + [0] zeros() = [0] mark(x1) = [1] x1 + [0] cons(x1, x2) = [1] x1 + [1] x2 + [0] 0() = [0] and(x1, x2) = [1] x1 + [1] x2 + [0] tt() = [0] length(x1) = [1] x1 + [0] nil() = [0] s(x1) = [1] x1 + [0] proper(x1) = [1] x1 + [1] ok(x1) = [1] x1 + [1] top(x1) = [0] x1 + [0] active^#(x1) = [0] x1 + [0] c_0(x1) = [0] x1 + [0] cons^#(x1, x2) = [0] x1 + [0] x2 + [0] c_1() = [0] c_2() = [0] c_3(x1) = [0] x1 + [0] s^#(x1) = [0] x1 + [0] c_4(x1) = [0] x1 + [0] c_5(x1) = [0] x1 + [0] and^#(x1, x2) = [0] x1 + [0] x2 + [0] c_6(x1) = [0] x1 + [0] length^#(x1) = [1] x1 + [0] c_7(x1) = [0] x1 + [0] c_8(x1) = [0] x1 + [0] c_9(x1) = [0] x1 + [0] c_10(x1) = [1] x1 + [1] c_11(x1) = [0] x1 + [0] proper^#(x1) = [1] x1 + [9] c_12() = [0] c_13(x1) = [0] x1 + [0] c_14() = [0] c_15(x1) = [0] x1 + [0] c_16() = [0] c_17(x1) = [1] x1 + [0] c_18() = [0] c_19(x1) = [0] x1 + [0] c_20(x1) = [0] x1 + [0] c_21(x1) = [0] x1 + [0] c_22(x1) = [1] x1 + [1] c_23(x1) = [0] x1 + [0] top^#(x1) = [0] x1 + [0] c_24(x1) = [0] x1 + [0] c_25(x1) = [0] x1 + [0] Finally we apply the subprocessor We apply the weight gap principle, strictly orienting the rules {length^#(mark(X)) -> c_10(length^#(X))} and weakly orienting the rules { proper^#(length(X)) -> c_17(length^#(proper(X))) , cons(ok(X1), ok(X2)) -> ok(cons(X1, X2)) , and(ok(X1), ok(X2)) -> ok(and(X1, X2)) , length^#(ok(X)) -> c_22(length^#(X))} using the following strongly linear interpretation: Processor 'Matrix Interpretation' oriented the following rules strictly: {length^#(mark(X)) -> c_10(length^#(X))} Details: Interpretation Functions: active(x1) = [0] x1 + [0] zeros() = [0] mark(x1) = [1] x1 + [8] cons(x1, x2) = [1] x1 + [1] x2 + [0] 0() = [0] and(x1, x2) = [1] x1 + [1] x2 + [0] tt() = [0] length(x1) = [1] x1 + [0] nil() = [0] s(x1) = [1] x1 + [0] proper(x1) = [1] x1 + [1] ok(x1) = [1] x1 + [1] top(x1) = [0] x1 + [0] active^#(x1) = [0] x1 + [0] c_0(x1) = [0] x1 + [0] cons^#(x1, x2) = [0] x1 + [0] x2 + [0] c_1() = [0] c_2() = [0] c_3(x1) = [0] x1 + [0] s^#(x1) = [0] x1 + [0] c_4(x1) = [0] x1 + [0] c_5(x1) = [0] x1 + [0] and^#(x1, x2) = [0] x1 + [0] x2 + [0] c_6(x1) = [0] x1 + [0] length^#(x1) = [1] x1 + [0] c_7(x1) = [0] x1 + [0] c_8(x1) = [0] x1 + [0] c_9(x1) = [0] x1 + [0] c_10(x1) = [1] x1 + [0] c_11(x1) = [0] x1 + [0] proper^#(x1) = [1] x1 + [9] c_12() = [0] c_13(x1) = [0] x1 + [0] c_14() = [0] c_15(x1) = [0] x1 + [0] c_16() = [0] c_17(x1) = [1] x1 + [0] c_18() = [0] c_19(x1) = [0] x1 + [0] c_20(x1) = [0] x1 + [0] c_21(x1) = [0] x1 + [0] c_22(x1) = [1] x1 + [1] c_23(x1) = [0] x1 + [0] top^#(x1) = [0] x1 + [0] c_24(x1) = [0] x1 + [0] c_25(x1) = [0] x1 + [0] Finally we apply the subprocessor We apply the weight gap principle, strictly orienting the rules { proper(zeros()) -> ok(zeros()) , proper(0()) -> ok(0()) , proper(tt()) -> ok(tt()) , proper(nil()) -> ok(nil())} and weakly orienting the rules { length^#(mark(X)) -> c_10(length^#(X)) , proper^#(length(X)) -> c_17(length^#(proper(X))) , cons(ok(X1), ok(X2)) -> ok(cons(X1, X2)) , and(ok(X1), ok(X2)) -> ok(and(X1, X2)) , length^#(ok(X)) -> c_22(length^#(X))} using the following strongly linear interpretation: Processor 'Matrix Interpretation' oriented the following rules strictly: { proper(zeros()) -> ok(zeros()) , proper(0()) -> ok(0()) , proper(tt()) -> ok(tt()) , proper(nil()) -> ok(nil())} Details: Interpretation Functions: active(x1) = [0] x1 + [0] zeros() = [0] mark(x1) = [1] x1 + [0] cons(x1, x2) = [1] x1 + [1] x2 + [0] 0() = [12] and(x1, x2) = [1] x1 + [1] x2 + [0] tt() = [0] length(x1) = [1] x1 + [0] nil() = [0] s(x1) = [1] x1 + [0] proper(x1) = [1] x1 + [1] ok(x1) = [1] x1 + [0] top(x1) = [0] x1 + [0] active^#(x1) = [0] x1 + [0] c_0(x1) = [0] x1 + [0] cons^#(x1, x2) = [0] x1 + [0] x2 + [0] c_1() = [0] c_2() = [0] c_3(x1) = [0] x1 + [0] s^#(x1) = [0] x1 + [0] c_4(x1) = [0] x1 + [0] c_5(x1) = [0] x1 + [0] and^#(x1, x2) = [0] x1 + [0] x2 + [0] c_6(x1) = [0] x1 + [0] length^#(x1) = [1] x1 + [5] c_7(x1) = [0] x1 + [0] c_8(x1) = [0] x1 + [0] c_9(x1) = [0] x1 + [0] c_10(x1) = [1] x1 + [0] c_11(x1) = [0] x1 + [0] proper^#(x1) = [1] x1 + [9] c_12() = [0] c_13(x1) = [0] x1 + [0] c_14() = [0] c_15(x1) = [0] x1 + [0] c_16() = [0] c_17(x1) = [1] x1 + [1] c_18() = [0] c_19(x1) = [0] x1 + [0] c_20(x1) = [0] x1 + [0] c_21(x1) = [0] x1 + [0] c_22(x1) = [1] x1 + [0] c_23(x1) = [0] x1 + [0] top^#(x1) = [0] x1 + [0] c_24(x1) = [0] x1 + [0] c_25(x1) = [0] x1 + [0] Finally we apply the subprocessor 'fastest of 'combine', 'Bounds with default enrichment', 'Bounds with default enrichment'' ------------------------------------------------------------------------------------------ Answer: YES(?,O(n^1)) Input Problem: innermost relative runtime-complexity with respect to Strict Rules: { proper(cons(X1, X2)) -> cons(proper(X1), proper(X2)) , proper(and(X1, X2)) -> and(proper(X1), proper(X2)) , proper(length(X)) -> length(proper(X)) , proper(s(X)) -> s(proper(X)) , length(mark(X)) -> mark(length(X)) , length(ok(X)) -> ok(length(X)) , cons(mark(X1), X2) -> mark(cons(X1, X2)) , and(mark(X1), X2) -> mark(and(X1, X2)) , s(mark(X)) -> mark(s(X)) , s(ok(X)) -> ok(s(X))} Weak Rules: { proper(zeros()) -> ok(zeros()) , proper(0()) -> ok(0()) , proper(tt()) -> ok(tt()) , proper(nil()) -> ok(nil()) , length^#(mark(X)) -> c_10(length^#(X)) , proper^#(length(X)) -> c_17(length^#(proper(X))) , cons(ok(X1), ok(X2)) -> ok(cons(X1, X2)) , and(ok(X1), ok(X2)) -> ok(and(X1, X2)) , length^#(ok(X)) -> c_22(length^#(X))} Details: The problem was solved by processor 'Bounds with default enrichment': 'Bounds with default enrichment' -------------------------------- Answer: YES(?,O(n^1)) Input Problem: innermost relative runtime-complexity with respect to Strict Rules: { proper(cons(X1, X2)) -> cons(proper(X1), proper(X2)) , proper(and(X1, X2)) -> and(proper(X1), proper(X2)) , proper(length(X)) -> length(proper(X)) , proper(s(X)) -> s(proper(X)) , length(mark(X)) -> mark(length(X)) , length(ok(X)) -> ok(length(X)) , cons(mark(X1), X2) -> mark(cons(X1, X2)) , and(mark(X1), X2) -> mark(and(X1, X2)) , s(mark(X)) -> mark(s(X)) , s(ok(X)) -> ok(s(X))} Weak Rules: { proper(zeros()) -> ok(zeros()) , proper(0()) -> ok(0()) , proper(tt()) -> ok(tt()) , proper(nil()) -> ok(nil()) , length^#(mark(X)) -> c_10(length^#(X)) , proper^#(length(X)) -> c_17(length^#(proper(X))) , cons(ok(X1), ok(X2)) -> ok(cons(X1, X2)) , and(ok(X1), ok(X2)) -> ok(and(X1, X2)) , length^#(ok(X)) -> c_22(length^#(X))} Details: The problem is Match-bounded by 0. The enriched problem is compatible with the following automaton: { zeros_0() -> 2 , mark_0(2) -> 3 , mark_0(3) -> 3 , mark_0(5) -> 3 , mark_0(7) -> 3 , mark_0(9) -> 3 , mark_0(12) -> 3 , 0_0() -> 5 , tt_0() -> 7 , nil_0() -> 9 , ok_0(2) -> 12 , ok_0(3) -> 12 , ok_0(5) -> 12 , ok_0(7) -> 12 , ok_0(9) -> 12 , ok_0(12) -> 12 , length^#_0(2) -> 25 , length^#_0(3) -> 25 , length^#_0(5) -> 25 , length^#_0(7) -> 25 , length^#_0(9) -> 25 , length^#_0(12) -> 25 , c_10_0(25) -> 25 , proper^#_0(2) -> 31 , proper^#_0(3) -> 31 , proper^#_0(5) -> 31 , proper^#_0(7) -> 31 , proper^#_0(9) -> 31 , proper^#_0(12) -> 31 , c_22_0(25) -> 25} 13) { proper^#(s(X)) -> c_19(s^#(proper(X))) , s^#(ok(X)) -> c_23(s^#(X)) , s^#(mark(X)) -> c_11(s^#(X))} The usable rules for this path are the following: { proper(zeros()) -> ok(zeros()) , proper(cons(X1, X2)) -> cons(proper(X1), proper(X2)) , proper(0()) -> ok(0()) , proper(and(X1, X2)) -> and(proper(X1), proper(X2)) , proper(tt()) -> ok(tt()) , proper(length(X)) -> length(proper(X)) , proper(nil()) -> ok(nil()) , proper(s(X)) -> s(proper(X)) , length(mark(X)) -> mark(length(X)) , length(ok(X)) -> ok(length(X)) , cons(mark(X1), X2) -> mark(cons(X1, X2)) , and(mark(X1), X2) -> mark(and(X1, X2)) , s(mark(X)) -> mark(s(X)) , cons(ok(X1), ok(X2)) -> ok(cons(X1, X2)) , and(ok(X1), ok(X2)) -> ok(and(X1, X2)) , s(ok(X)) -> ok(s(X))} We have applied the subprocessor on the union of usable rules and weak (innermost) dependency pairs. 'Weight Gap Principle' ---------------------- Answer: YES(?,O(n^1)) Input Problem: innermost runtime-complexity with respect to Rules: { proper(zeros()) -> ok(zeros()) , proper(cons(X1, X2)) -> cons(proper(X1), proper(X2)) , proper(0()) -> ok(0()) , proper(and(X1, X2)) -> and(proper(X1), proper(X2)) , proper(tt()) -> ok(tt()) , proper(length(X)) -> length(proper(X)) , proper(nil()) -> ok(nil()) , proper(s(X)) -> s(proper(X)) , length(mark(X)) -> mark(length(X)) , length(ok(X)) -> ok(length(X)) , cons(mark(X1), X2) -> mark(cons(X1, X2)) , and(mark(X1), X2) -> mark(and(X1, X2)) , s(mark(X)) -> mark(s(X)) , cons(ok(X1), ok(X2)) -> ok(cons(X1, X2)) , and(ok(X1), ok(X2)) -> ok(and(X1, X2)) , s(ok(X)) -> ok(s(X)) , proper^#(s(X)) -> c_19(s^#(proper(X))) , s^#(ok(X)) -> c_23(s^#(X)) , s^#(mark(X)) -> c_11(s^#(X))} Details: We apply the weight gap principle, strictly orienting the rules { cons(ok(X1), ok(X2)) -> ok(cons(X1, X2)) , and(ok(X1), ok(X2)) -> ok(and(X1, X2)) , s^#(ok(X)) -> c_23(s^#(X))} and weakly orienting the rules {} using the following strongly linear interpretation: Processor 'Matrix Interpretation' oriented the following rules strictly: { cons(ok(X1), ok(X2)) -> ok(cons(X1, X2)) , and(ok(X1), ok(X2)) -> ok(and(X1, X2)) , s^#(ok(X)) -> c_23(s^#(X))} Details: Interpretation Functions: active(x1) = [0] x1 + [0] zeros() = [0] mark(x1) = [1] x1 + [0] cons(x1, x2) = [1] x1 + [1] x2 + [0] 0() = [0] and(x1, x2) = [1] x1 + [1] x2 + [0] tt() = [0] length(x1) = [1] x1 + [0] nil() = [0] s(x1) = [1] x1 + [0] proper(x1) = [1] x1 + [1] ok(x1) = [1] x1 + [1] top(x1) = [0] x1 + [0] active^#(x1) = [0] x1 + [0] c_0(x1) = [0] x1 + [0] cons^#(x1, x2) = [0] x1 + [0] x2 + [0] c_1() = [0] c_2() = [0] c_3(x1) = [0] x1 + [0] s^#(x1) = [1] x1 + [3] c_4(x1) = [0] x1 + [0] c_5(x1) = [0] x1 + [0] and^#(x1, x2) = [0] x1 + [0] x2 + [0] c_6(x1) = [0] x1 + [0] length^#(x1) = [0] x1 + [0] c_7(x1) = [0] x1 + [0] c_8(x1) = [0] x1 + [0] c_9(x1) = [0] x1 + [0] c_10(x1) = [0] x1 + [0] c_11(x1) = [1] x1 + [0] proper^#(x1) = [1] x1 + [1] c_12() = [0] c_13(x1) = [0] x1 + [0] c_14() = [0] c_15(x1) = [0] x1 + [0] c_16() = [0] c_17(x1) = [0] x1 + [0] c_18() = [0] c_19(x1) = [1] x1 + [1] c_20(x1) = [0] x1 + [0] c_21(x1) = [0] x1 + [0] c_22(x1) = [0] x1 + [0] c_23(x1) = [1] x1 + [0] top^#(x1) = [0] x1 + [0] c_24(x1) = [0] x1 + [0] c_25(x1) = [0] x1 + [0] Finally we apply the subprocessor We apply the weight gap principle, strictly orienting the rules {proper^#(s(X)) -> c_19(s^#(proper(X)))} and weakly orienting the rules { cons(ok(X1), ok(X2)) -> ok(cons(X1, X2)) , and(ok(X1), ok(X2)) -> ok(and(X1, X2)) , s^#(ok(X)) -> c_23(s^#(X))} using the following strongly linear interpretation: Processor 'Matrix Interpretation' oriented the following rules strictly: {proper^#(s(X)) -> c_19(s^#(proper(X)))} Details: Interpretation Functions: active(x1) = [0] x1 + [0] zeros() = [0] mark(x1) = [1] x1 + [0] cons(x1, x2) = [1] x1 + [1] x2 + [0] 0() = [0] and(x1, x2) = [1] x1 + [1] x2 + [0] tt() = [0] length(x1) = [1] x1 + [0] nil() = [0] s(x1) = [1] x1 + [0] proper(x1) = [1] x1 + [1] ok(x1) = [1] x1 + [1] top(x1) = [0] x1 + [0] active^#(x1) = [0] x1 + [0] c_0(x1) = [0] x1 + [0] cons^#(x1, x2) = [0] x1 + [0] x2 + [0] c_1() = [0] c_2() = [0] c_3(x1) = [0] x1 + [0] s^#(x1) = [1] x1 + [0] c_4(x1) = [0] x1 + [0] c_5(x1) = [0] x1 + [0] and^#(x1, x2) = [0] x1 + [0] x2 + [0] c_6(x1) = [0] x1 + [0] length^#(x1) = [0] x1 + [0] c_7(x1) = [0] x1 + [0] c_8(x1) = [0] x1 + [0] c_9(x1) = [0] x1 + [0] c_10(x1) = [0] x1 + [0] c_11(x1) = [1] x1 + [1] proper^#(x1) = [1] x1 + [9] c_12() = [0] c_13(x1) = [0] x1 + [0] c_14() = [0] c_15(x1) = [0] x1 + [0] c_16() = [0] c_17(x1) = [0] x1 + [0] c_18() = [0] c_19(x1) = [1] x1 + [0] c_20(x1) = [0] x1 + [0] c_21(x1) = [0] x1 + [0] c_22(x1) = [0] x1 + [0] c_23(x1) = [1] x1 + [1] top^#(x1) = [0] x1 + [0] c_24(x1) = [0] x1 + [0] c_25(x1) = [0] x1 + [0] Finally we apply the subprocessor We apply the weight gap principle, strictly orienting the rules {s^#(mark(X)) -> c_11(s^#(X))} and weakly orienting the rules { proper^#(s(X)) -> c_19(s^#(proper(X))) , cons(ok(X1), ok(X2)) -> ok(cons(X1, X2)) , and(ok(X1), ok(X2)) -> ok(and(X1, X2)) , s^#(ok(X)) -> c_23(s^#(X))} using the following strongly linear interpretation: Processor 'Matrix Interpretation' oriented the following rules strictly: {s^#(mark(X)) -> c_11(s^#(X))} Details: Interpretation Functions: active(x1) = [0] x1 + [0] zeros() = [0] mark(x1) = [1] x1 + [8] cons(x1, x2) = [1] x1 + [1] x2 + [0] 0() = [0] and(x1, x2) = [1] x1 + [1] x2 + [3] tt() = [8] length(x1) = [1] x1 + [8] nil() = [0] s(x1) = [1] x1 + [8] proper(x1) = [1] x1 + [1] ok(x1) = [1] x1 + [1] top(x1) = [0] x1 + [0] active^#(x1) = [0] x1 + [0] c_0(x1) = [0] x1 + [0] cons^#(x1, x2) = [0] x1 + [0] x2 + [0] c_1() = [0] c_2() = [0] c_3(x1) = [0] x1 + [0] s^#(x1) = [1] x1 + [12] c_4(x1) = [0] x1 + [0] c_5(x1) = [0] x1 + [0] and^#(x1, x2) = [0] x1 + [0] x2 + [0] c_6(x1) = [0] x1 + [0] length^#(x1) = [0] x1 + [0] c_7(x1) = [0] x1 + [0] c_8(x1) = [0] x1 + [0] c_9(x1) = [0] x1 + [0] c_10(x1) = [0] x1 + [0] c_11(x1) = [1] x1 + [0] proper^#(x1) = [1] x1 + [12] c_12() = [0] c_13(x1) = [0] x1 + [0] c_14() = [0] c_15(x1) = [0] x1 + [0] c_16() = [0] c_17(x1) = [0] x1 + [0] c_18() = [0] c_19(x1) = [1] x1 + [3] c_20(x1) = [0] x1 + [0] c_21(x1) = [0] x1 + [0] c_22(x1) = [0] x1 + [0] c_23(x1) = [1] x1 + [0] top^#(x1) = [0] x1 + [0] c_24(x1) = [0] x1 + [0] c_25(x1) = [0] x1 + [0] Finally we apply the subprocessor We apply the weight gap principle, strictly orienting the rules { proper(zeros()) -> ok(zeros()) , proper(0()) -> ok(0()) , proper(tt()) -> ok(tt()) , proper(nil()) -> ok(nil())} and weakly orienting the rules { s^#(mark(X)) -> c_11(s^#(X)) , proper^#(s(X)) -> c_19(s^#(proper(X))) , cons(ok(X1), ok(X2)) -> ok(cons(X1, X2)) , and(ok(X1), ok(X2)) -> ok(and(X1, X2)) , s^#(ok(X)) -> c_23(s^#(X))} using the following strongly linear interpretation: Processor 'Matrix Interpretation' oriented the following rules strictly: { proper(zeros()) -> ok(zeros()) , proper(0()) -> ok(0()) , proper(tt()) -> ok(tt()) , proper(nil()) -> ok(nil())} Details: Interpretation Functions: active(x1) = [0] x1 + [0] zeros() = [0] mark(x1) = [1] x1 + [0] cons(x1, x2) = [1] x1 + [1] x2 + [0] 0() = [0] and(x1, x2) = [1] x1 + [1] x2 + [0] tt() = [12] length(x1) = [1] x1 + [0] nil() = [12] s(x1) = [1] x1 + [8] proper(x1) = [1] x1 + [1] ok(x1) = [1] x1 + [0] top(x1) = [0] x1 + [0] active^#(x1) = [0] x1 + [0] c_0(x1) = [0] x1 + [0] cons^#(x1, x2) = [0] x1 + [0] x2 + [0] c_1() = [0] c_2() = [0] c_3(x1) = [0] x1 + [0] s^#(x1) = [1] x1 + [1] c_4(x1) = [0] x1 + [0] c_5(x1) = [0] x1 + [0] and^#(x1, x2) = [0] x1 + [0] x2 + [0] c_6(x1) = [0] x1 + [0] length^#(x1) = [0] x1 + [0] c_7(x1) = [0] x1 + [0] c_8(x1) = [0] x1 + [0] c_9(x1) = [0] x1 + [0] c_10(x1) = [0] x1 + [0] c_11(x1) = [1] x1 + [0] proper^#(x1) = [1] x1 + [3] c_12() = [0] c_13(x1) = [0] x1 + [0] c_14() = [0] c_15(x1) = [0] x1 + [0] c_16() = [0] c_17(x1) = [0] x1 + [0] c_18() = [0] c_19(x1) = [1] x1 + [2] c_20(x1) = [0] x1 + [0] c_21(x1) = [0] x1 + [0] c_22(x1) = [0] x1 + [0] c_23(x1) = [1] x1 + [0] top^#(x1) = [0] x1 + [0] c_24(x1) = [0] x1 + [0] c_25(x1) = [0] x1 + [0] Finally we apply the subprocessor 'fastest of 'combine', 'Bounds with default enrichment', 'Bounds with default enrichment'' ------------------------------------------------------------------------------------------ Answer: YES(?,O(n^1)) Input Problem: innermost relative runtime-complexity with respect to Strict Rules: { proper(cons(X1, X2)) -> cons(proper(X1), proper(X2)) , proper(and(X1, X2)) -> and(proper(X1), proper(X2)) , proper(length(X)) -> length(proper(X)) , proper(s(X)) -> s(proper(X)) , length(mark(X)) -> mark(length(X)) , length(ok(X)) -> ok(length(X)) , cons(mark(X1), X2) -> mark(cons(X1, X2)) , and(mark(X1), X2) -> mark(and(X1, X2)) , s(mark(X)) -> mark(s(X)) , s(ok(X)) -> ok(s(X))} Weak Rules: { proper(zeros()) -> ok(zeros()) , proper(0()) -> ok(0()) , proper(tt()) -> ok(tt()) , proper(nil()) -> ok(nil()) , s^#(mark(X)) -> c_11(s^#(X)) , proper^#(s(X)) -> c_19(s^#(proper(X))) , cons(ok(X1), ok(X2)) -> ok(cons(X1, X2)) , and(ok(X1), ok(X2)) -> ok(and(X1, X2)) , s^#(ok(X)) -> c_23(s^#(X))} Details: The problem was solved by processor 'Bounds with default enrichment': 'Bounds with default enrichment' -------------------------------- Answer: YES(?,O(n^1)) Input Problem: innermost relative runtime-complexity with respect to Strict Rules: { proper(cons(X1, X2)) -> cons(proper(X1), proper(X2)) , proper(and(X1, X2)) -> and(proper(X1), proper(X2)) , proper(length(X)) -> length(proper(X)) , proper(s(X)) -> s(proper(X)) , length(mark(X)) -> mark(length(X)) , length(ok(X)) -> ok(length(X)) , cons(mark(X1), X2) -> mark(cons(X1, X2)) , and(mark(X1), X2) -> mark(and(X1, X2)) , s(mark(X)) -> mark(s(X)) , s(ok(X)) -> ok(s(X))} Weak Rules: { proper(zeros()) -> ok(zeros()) , proper(0()) -> ok(0()) , proper(tt()) -> ok(tt()) , proper(nil()) -> ok(nil()) , s^#(mark(X)) -> c_11(s^#(X)) , proper^#(s(X)) -> c_19(s^#(proper(X))) , cons(ok(X1), ok(X2)) -> ok(cons(X1, X2)) , and(ok(X1), ok(X2)) -> ok(and(X1, X2)) , s^#(ok(X)) -> c_23(s^#(X))} Details: The problem is Match-bounded by 0. The enriched problem is compatible with the following automaton: { zeros_0() -> 2 , mark_0(2) -> 3 , mark_0(3) -> 3 , mark_0(5) -> 3 , mark_0(7) -> 3 , mark_0(9) -> 3 , mark_0(12) -> 3 , 0_0() -> 5 , tt_0() -> 7 , nil_0() -> 9 , ok_0(2) -> 12 , ok_0(3) -> 12 , ok_0(5) -> 12 , ok_0(7) -> 12 , ok_0(9) -> 12 , ok_0(12) -> 12 , s^#_0(2) -> 20 , s^#_0(3) -> 20 , s^#_0(5) -> 20 , s^#_0(7) -> 20 , s^#_0(9) -> 20 , s^#_0(12) -> 20 , c_11_0(20) -> 20 , proper^#_0(2) -> 31 , proper^#_0(3) -> 31 , proper^#_0(5) -> 31 , proper^#_0(7) -> 31 , proper^#_0(9) -> 31 , proper^#_0(12) -> 31 , c_23_0(20) -> 20} 14) {proper^#(and(X1, X2)) -> c_15(and^#(proper(X1), proper(X2)))} The usable rules for this path are the following: { proper(zeros()) -> ok(zeros()) , proper(cons(X1, X2)) -> cons(proper(X1), proper(X2)) , proper(0()) -> ok(0()) , proper(and(X1, X2)) -> and(proper(X1), proper(X2)) , proper(tt()) -> ok(tt()) , proper(length(X)) -> length(proper(X)) , proper(nil()) -> ok(nil()) , proper(s(X)) -> s(proper(X)) , length(mark(X)) -> mark(length(X)) , length(ok(X)) -> ok(length(X)) , cons(mark(X1), X2) -> mark(cons(X1, X2)) , and(mark(X1), X2) -> mark(and(X1, X2)) , s(mark(X)) -> mark(s(X)) , cons(ok(X1), ok(X2)) -> ok(cons(X1, X2)) , and(ok(X1), ok(X2)) -> ok(and(X1, X2)) , s(ok(X)) -> ok(s(X))} We have applied the subprocessor on the union of usable rules and weak (innermost) dependency pairs. 'Weight Gap Principle' ---------------------- Answer: YES(?,O(n^1)) Input Problem: innermost runtime-complexity with respect to Rules: { proper(zeros()) -> ok(zeros()) , proper(cons(X1, X2)) -> cons(proper(X1), proper(X2)) , proper(0()) -> ok(0()) , proper(and(X1, X2)) -> and(proper(X1), proper(X2)) , proper(tt()) -> ok(tt()) , proper(length(X)) -> length(proper(X)) , proper(nil()) -> ok(nil()) , proper(s(X)) -> s(proper(X)) , length(mark(X)) -> mark(length(X)) , length(ok(X)) -> ok(length(X)) , cons(mark(X1), X2) -> mark(cons(X1, X2)) , and(mark(X1), X2) -> mark(and(X1, X2)) , s(mark(X)) -> mark(s(X)) , cons(ok(X1), ok(X2)) -> ok(cons(X1, X2)) , and(ok(X1), ok(X2)) -> ok(and(X1, X2)) , s(ok(X)) -> ok(s(X)) , proper^#(and(X1, X2)) -> c_15(and^#(proper(X1), proper(X2)))} Details: We apply the weight gap principle, strictly orienting the rules { cons(ok(X1), ok(X2)) -> ok(cons(X1, X2)) , and(ok(X1), ok(X2)) -> ok(and(X1, X2))} and weakly orienting the rules {} using the following strongly linear interpretation: Processor 'Matrix Interpretation' oriented the following rules strictly: { cons(ok(X1), ok(X2)) -> ok(cons(X1, X2)) , and(ok(X1), ok(X2)) -> ok(and(X1, X2))} Details: Interpretation Functions: active(x1) = [0] x1 + [0] zeros() = [0] mark(x1) = [1] x1 + [0] cons(x1, x2) = [1] x1 + [1] x2 + [0] 0() = [0] and(x1, x2) = [1] x1 + [1] x2 + [0] tt() = [0] length(x1) = [1] x1 + [0] nil() = [0] s(x1) = [1] x1 + [0] proper(x1) = [1] x1 + [1] ok(x1) = [1] x1 + [1] top(x1) = [0] x1 + [0] active^#(x1) = [0] x1 + [0] c_0(x1) = [0] x1 + [0] cons^#(x1, x2) = [0] x1 + [0] x2 + [0] c_1() = [0] c_2() = [0] c_3(x1) = [0] x1 + [0] s^#(x1) = [0] x1 + [0] c_4(x1) = [0] x1 + [0] c_5(x1) = [0] x1 + [0] and^#(x1, x2) = [1] x1 + [1] x2 + [0] c_6(x1) = [0] x1 + [0] length^#(x1) = [0] x1 + [0] c_7(x1) = [0] x1 + [0] c_8(x1) = [0] x1 + [0] c_9(x1) = [0] x1 + [0] c_10(x1) = [0] x1 + [0] c_11(x1) = [0] x1 + [0] proper^#(x1) = [1] x1 + [1] c_12() = [0] c_13(x1) = [0] x1 + [0] c_14() = [0] c_15(x1) = [1] x1 + [1] c_16() = [0] c_17(x1) = [0] x1 + [0] c_18() = [0] c_19(x1) = [0] x1 + [0] c_20(x1) = [0] x1 + [0] c_21(x1) = [0] x1 + [0] c_22(x1) = [0] x1 + [0] c_23(x1) = [0] x1 + [0] top^#(x1) = [0] x1 + [0] c_24(x1) = [0] x1 + [0] c_25(x1) = [0] x1 + [0] Finally we apply the subprocessor We apply the weight gap principle, strictly orienting the rules { proper(zeros()) -> ok(zeros()) , proper(0()) -> ok(0()) , proper(tt()) -> ok(tt()) , proper(nil()) -> ok(nil())} and weakly orienting the rules { cons(ok(X1), ok(X2)) -> ok(cons(X1, X2)) , and(ok(X1), ok(X2)) -> ok(and(X1, X2))} using the following strongly linear interpretation: Processor 'Matrix Interpretation' oriented the following rules strictly: { proper(zeros()) -> ok(zeros()) , proper(0()) -> ok(0()) , proper(tt()) -> ok(tt()) , proper(nil()) -> ok(nil())} Details: Interpretation Functions: active(x1) = [0] x1 + [0] zeros() = [0] mark(x1) = [1] x1 + [0] cons(x1, x2) = [1] x1 + [1] x2 + [0] 0() = [4] and(x1, x2) = [1] x1 + [1] x2 + [0] tt() = [2] length(x1) = [1] x1 + [0] nil() = [0] s(x1) = [1] x1 + [0] proper(x1) = [1] x1 + [1] ok(x1) = [1] x1 + [0] top(x1) = [0] x1 + [0] active^#(x1) = [0] x1 + [0] c_0(x1) = [0] x1 + [0] cons^#(x1, x2) = [0] x1 + [0] x2 + [0] c_1() = [0] c_2() = [0] c_3(x1) = [0] x1 + [0] s^#(x1) = [0] x1 + [0] c_4(x1) = [0] x1 + [0] c_5(x1) = [0] x1 + [0] and^#(x1, x2) = [1] x1 + [1] x2 + [7] c_6(x1) = [0] x1 + [0] length^#(x1) = [0] x1 + [0] c_7(x1) = [0] x1 + [0] c_8(x1) = [0] x1 + [0] c_9(x1) = [0] x1 + [0] c_10(x1) = [0] x1 + [0] c_11(x1) = [0] x1 + [0] proper^#(x1) = [1] x1 + [1] c_12() = [0] c_13(x1) = [0] x1 + [0] c_14() = [0] c_15(x1) = [1] x1 + [9] c_16() = [0] c_17(x1) = [0] x1 + [0] c_18() = [0] c_19(x1) = [0] x1 + [0] c_20(x1) = [0] x1 + [0] c_21(x1) = [0] x1 + [0] c_22(x1) = [0] x1 + [0] c_23(x1) = [0] x1 + [0] top^#(x1) = [0] x1 + [0] c_24(x1) = [0] x1 + [0] c_25(x1) = [0] x1 + [0] Finally we apply the subprocessor We apply the weight gap principle, strictly orienting the rules {proper^#(and(X1, X2)) -> c_15(and^#(proper(X1), proper(X2)))} and weakly orienting the rules { proper(zeros()) -> ok(zeros()) , proper(0()) -> ok(0()) , proper(tt()) -> ok(tt()) , proper(nil()) -> ok(nil()) , cons(ok(X1), ok(X2)) -> ok(cons(X1, X2)) , and(ok(X1), ok(X2)) -> ok(and(X1, X2))} using the following strongly linear interpretation: Processor 'Matrix Interpretation' oriented the following rules strictly: {proper^#(and(X1, X2)) -> c_15(and^#(proper(X1), proper(X2)))} Details: Interpretation Functions: active(x1) = [0] x1 + [0] zeros() = [0] mark(x1) = [1] x1 + [0] cons(x1, x2) = [1] x1 + [1] x2 + [0] 0() = [0] and(x1, x2) = [1] x1 + [1] x2 + [0] tt() = [0] length(x1) = [1] x1 + [0] nil() = [0] s(x1) = [1] x1 + [0] proper(x1) = [1] x1 + [1] ok(x1) = [1] x1 + [0] top(x1) = [0] x1 + [0] active^#(x1) = [0] x1 + [0] c_0(x1) = [0] x1 + [0] cons^#(x1, x2) = [0] x1 + [0] x2 + [0] c_1() = [0] c_2() = [0] c_3(x1) = [0] x1 + [0] s^#(x1) = [0] x1 + [0] c_4(x1) = [0] x1 + [0] c_5(x1) = [0] x1 + [0] and^#(x1, x2) = [1] x1 + [1] x2 + [0] c_6(x1) = [0] x1 + [0] length^#(x1) = [0] x1 + [0] c_7(x1) = [0] x1 + [0] c_8(x1) = [0] x1 + [0] c_9(x1) = [0] x1 + [0] c_10(x1) = [0] x1 + [0] c_11(x1) = [0] x1 + [0] proper^#(x1) = [1] x1 + [9] c_12() = [0] c_13(x1) = [0] x1 + [0] c_14() = [0] c_15(x1) = [1] x1 + [1] c_16() = [0] c_17(x1) = [0] x1 + [0] c_18() = [0] c_19(x1) = [0] x1 + [0] c_20(x1) = [0] x1 + [0] c_21(x1) = [0] x1 + [0] c_22(x1) = [0] x1 + [0] c_23(x1) = [0] x1 + [0] top^#(x1) = [0] x1 + [0] c_24(x1) = [0] x1 + [0] c_25(x1) = [0] x1 + [0] Finally we apply the subprocessor 'fastest of 'combine', 'Bounds with default enrichment', 'Bounds with default enrichment'' ------------------------------------------------------------------------------------------ Answer: YES(?,O(n^1)) Input Problem: innermost relative runtime-complexity with respect to Strict Rules: { proper(cons(X1, X2)) -> cons(proper(X1), proper(X2)) , proper(and(X1, X2)) -> and(proper(X1), proper(X2)) , proper(length(X)) -> length(proper(X)) , proper(s(X)) -> s(proper(X)) , length(mark(X)) -> mark(length(X)) , length(ok(X)) -> ok(length(X)) , cons(mark(X1), X2) -> mark(cons(X1, X2)) , and(mark(X1), X2) -> mark(and(X1, X2)) , s(mark(X)) -> mark(s(X)) , s(ok(X)) -> ok(s(X))} Weak Rules: { proper^#(and(X1, X2)) -> c_15(and^#(proper(X1), proper(X2))) , proper(zeros()) -> ok(zeros()) , proper(0()) -> ok(0()) , proper(tt()) -> ok(tt()) , proper(nil()) -> ok(nil()) , cons(ok(X1), ok(X2)) -> ok(cons(X1, X2)) , and(ok(X1), ok(X2)) -> ok(and(X1, X2))} Details: The problem was solved by processor 'Bounds with default enrichment': 'Bounds with default enrichment' -------------------------------- Answer: YES(?,O(n^1)) Input Problem: innermost relative runtime-complexity with respect to Strict Rules: { proper(cons(X1, X2)) -> cons(proper(X1), proper(X2)) , proper(and(X1, X2)) -> and(proper(X1), proper(X2)) , proper(length(X)) -> length(proper(X)) , proper(s(X)) -> s(proper(X)) , length(mark(X)) -> mark(length(X)) , length(ok(X)) -> ok(length(X)) , cons(mark(X1), X2) -> mark(cons(X1, X2)) , and(mark(X1), X2) -> mark(and(X1, X2)) , s(mark(X)) -> mark(s(X)) , s(ok(X)) -> ok(s(X))} Weak Rules: { proper^#(and(X1, X2)) -> c_15(and^#(proper(X1), proper(X2))) , proper(zeros()) -> ok(zeros()) , proper(0()) -> ok(0()) , proper(tt()) -> ok(tt()) , proper(nil()) -> ok(nil()) , cons(ok(X1), ok(X2)) -> ok(cons(X1, X2)) , and(ok(X1), ok(X2)) -> ok(and(X1, X2))} Details: The problem is Match-bounded by 0. The enriched problem is compatible with the following automaton: { zeros_0() -> 2 , mark_0(2) -> 3 , mark_0(3) -> 3 , mark_0(5) -> 3 , mark_0(7) -> 3 , mark_0(9) -> 3 , mark_0(12) -> 3 , 0_0() -> 5 , tt_0() -> 7 , nil_0() -> 9 , ok_0(2) -> 12 , ok_0(3) -> 12 , ok_0(5) -> 12 , ok_0(7) -> 12 , ok_0(9) -> 12 , ok_0(12) -> 12 , and^#_0(2, 2) -> 23 , and^#_0(2, 3) -> 23 , and^#_0(2, 5) -> 23 , and^#_0(2, 7) -> 23 , and^#_0(2, 9) -> 23 , and^#_0(2, 12) -> 23 , and^#_0(3, 2) -> 23 , and^#_0(3, 3) -> 23 , and^#_0(3, 5) -> 23 , and^#_0(3, 7) -> 23 , and^#_0(3, 9) -> 23 , and^#_0(3, 12) -> 23 , and^#_0(5, 2) -> 23 , and^#_0(5, 3) -> 23 , and^#_0(5, 5) -> 23 , and^#_0(5, 7) -> 23 , and^#_0(5, 9) -> 23 , and^#_0(5, 12) -> 23 , and^#_0(7, 2) -> 23 , and^#_0(7, 3) -> 23 , and^#_0(7, 5) -> 23 , and^#_0(7, 7) -> 23 , and^#_0(7, 9) -> 23 , and^#_0(7, 12) -> 23 , and^#_0(9, 2) -> 23 , and^#_0(9, 3) -> 23 , and^#_0(9, 5) -> 23 , and^#_0(9, 7) -> 23 , and^#_0(9, 9) -> 23 , and^#_0(9, 12) -> 23 , and^#_0(12, 2) -> 23 , and^#_0(12, 3) -> 23 , and^#_0(12, 5) -> 23 , and^#_0(12, 7) -> 23 , and^#_0(12, 9) -> 23 , and^#_0(12, 12) -> 23 , proper^#_0(2) -> 31 , proper^#_0(3) -> 31 , proper^#_0(5) -> 31 , proper^#_0(7) -> 31 , proper^#_0(9) -> 31 , proper^#_0(12) -> 31} 15) {proper^#(cons(X1, X2)) -> c_13(cons^#(proper(X1), proper(X2)))} The usable rules for this path are the following: { proper(zeros()) -> ok(zeros()) , proper(cons(X1, X2)) -> cons(proper(X1), proper(X2)) , proper(0()) -> ok(0()) , proper(and(X1, X2)) -> and(proper(X1), proper(X2)) , proper(tt()) -> ok(tt()) , proper(length(X)) -> length(proper(X)) , proper(nil()) -> ok(nil()) , proper(s(X)) -> s(proper(X)) , length(mark(X)) -> mark(length(X)) , length(ok(X)) -> ok(length(X)) , cons(mark(X1), X2) -> mark(cons(X1, X2)) , and(mark(X1), X2) -> mark(and(X1, X2)) , s(mark(X)) -> mark(s(X)) , cons(ok(X1), ok(X2)) -> ok(cons(X1, X2)) , and(ok(X1), ok(X2)) -> ok(and(X1, X2)) , s(ok(X)) -> ok(s(X))} We have applied the subprocessor on the union of usable rules and weak (innermost) dependency pairs. 'Weight Gap Principle' ---------------------- Answer: YES(?,O(n^1)) Input Problem: innermost runtime-complexity with respect to Rules: { proper(zeros()) -> ok(zeros()) , proper(cons(X1, X2)) -> cons(proper(X1), proper(X2)) , proper(0()) -> ok(0()) , proper(and(X1, X2)) -> and(proper(X1), proper(X2)) , proper(tt()) -> ok(tt()) , proper(length(X)) -> length(proper(X)) , proper(nil()) -> ok(nil()) , proper(s(X)) -> s(proper(X)) , length(mark(X)) -> mark(length(X)) , length(ok(X)) -> ok(length(X)) , cons(mark(X1), X2) -> mark(cons(X1, X2)) , and(mark(X1), X2) -> mark(and(X1, X2)) , s(mark(X)) -> mark(s(X)) , cons(ok(X1), ok(X2)) -> ok(cons(X1, X2)) , and(ok(X1), ok(X2)) -> ok(and(X1, X2)) , s(ok(X)) -> ok(s(X)) , proper^#(cons(X1, X2)) -> c_13(cons^#(proper(X1), proper(X2)))} Details: We apply the weight gap principle, strictly orienting the rules { cons(ok(X1), ok(X2)) -> ok(cons(X1, X2)) , and(ok(X1), ok(X2)) -> ok(and(X1, X2))} and weakly orienting the rules {} using the following strongly linear interpretation: Processor 'Matrix Interpretation' oriented the following rules strictly: { cons(ok(X1), ok(X2)) -> ok(cons(X1, X2)) , and(ok(X1), ok(X2)) -> ok(and(X1, X2))} Details: Interpretation Functions: active(x1) = [0] x1 + [0] zeros() = [0] mark(x1) = [1] x1 + [0] cons(x1, x2) = [1] x1 + [1] x2 + [0] 0() = [0] and(x1, x2) = [1] x1 + [1] x2 + [0] tt() = [0] length(x1) = [1] x1 + [0] nil() = [0] s(x1) = [1] x1 + [0] proper(x1) = [1] x1 + [1] ok(x1) = [1] x1 + [1] top(x1) = [0] x1 + [0] active^#(x1) = [0] x1 + [0] c_0(x1) = [0] x1 + [0] cons^#(x1, x2) = [1] x1 + [1] x2 + [2] c_1() = [0] c_2() = [0] c_3(x1) = [0] x1 + [0] s^#(x1) = [0] x1 + [0] c_4(x1) = [0] x1 + [0] c_5(x1) = [0] x1 + [0] and^#(x1, x2) = [0] x1 + [0] x2 + [0] c_6(x1) = [0] x1 + [0] length^#(x1) = [0] x1 + [0] c_7(x1) = [0] x1 + [0] c_8(x1) = [0] x1 + [0] c_9(x1) = [0] x1 + [0] c_10(x1) = [0] x1 + [0] c_11(x1) = [0] x1 + [0] proper^#(x1) = [1] x1 + [1] c_12() = [0] c_13(x1) = [1] x1 + [1] c_14() = [0] c_15(x1) = [0] x1 + [0] c_16() = [0] c_17(x1) = [0] x1 + [0] c_18() = [0] c_19(x1) = [0] x1 + [0] c_20(x1) = [0] x1 + [0] c_21(x1) = [0] x1 + [0] c_22(x1) = [0] x1 + [0] c_23(x1) = [0] x1 + [0] top^#(x1) = [0] x1 + [0] c_24(x1) = [0] x1 + [0] c_25(x1) = [0] x1 + [0] Finally we apply the subprocessor We apply the weight gap principle, strictly orienting the rules { proper(zeros()) -> ok(zeros()) , proper(0()) -> ok(0()) , proper(tt()) -> ok(tt()) , proper(nil()) -> ok(nil())} and weakly orienting the rules { cons(ok(X1), ok(X2)) -> ok(cons(X1, X2)) , and(ok(X1), ok(X2)) -> ok(and(X1, X2))} using the following strongly linear interpretation: Processor 'Matrix Interpretation' oriented the following rules strictly: { proper(zeros()) -> ok(zeros()) , proper(0()) -> ok(0()) , proper(tt()) -> ok(tt()) , proper(nil()) -> ok(nil())} Details: Interpretation Functions: active(x1) = [0] x1 + [0] zeros() = [0] mark(x1) = [1] x1 + [2] cons(x1, x2) = [1] x1 + [1] x2 + [0] 0() = [0] and(x1, x2) = [1] x1 + [1] x2 + [0] tt() = [0] length(x1) = [1] x1 + [0] nil() = [8] s(x1) = [1] x1 + [0] proper(x1) = [1] x1 + [1] ok(x1) = [1] x1 + [0] top(x1) = [0] x1 + [0] active^#(x1) = [0] x1 + [0] c_0(x1) = [0] x1 + [0] cons^#(x1, x2) = [1] x1 + [1] x2 + [8] c_1() = [0] c_2() = [0] c_3(x1) = [0] x1 + [0] s^#(x1) = [0] x1 + [0] c_4(x1) = [0] x1 + [0] c_5(x1) = [0] x1 + [0] and^#(x1, x2) = [0] x1 + [0] x2 + [0] c_6(x1) = [0] x1 + [0] length^#(x1) = [0] x1 + [0] c_7(x1) = [0] x1 + [0] c_8(x1) = [0] x1 + [0] c_9(x1) = [0] x1 + [0] c_10(x1) = [0] x1 + [0] c_11(x1) = [0] x1 + [0] proper^#(x1) = [1] x1 + [9] c_12() = [0] c_13(x1) = [1] x1 + [8] c_14() = [0] c_15(x1) = [0] x1 + [0] c_16() = [0] c_17(x1) = [0] x1 + [0] c_18() = [0] c_19(x1) = [0] x1 + [0] c_20(x1) = [0] x1 + [0] c_21(x1) = [0] x1 + [0] c_22(x1) = [0] x1 + [0] c_23(x1) = [0] x1 + [0] top^#(x1) = [0] x1 + [0] c_24(x1) = [0] x1 + [0] c_25(x1) = [0] x1 + [0] Finally we apply the subprocessor We apply the weight gap principle, strictly orienting the rules {proper^#(cons(X1, X2)) -> c_13(cons^#(proper(X1), proper(X2)))} and weakly orienting the rules { proper(zeros()) -> ok(zeros()) , proper(0()) -> ok(0()) , proper(tt()) -> ok(tt()) , proper(nil()) -> ok(nil()) , cons(ok(X1), ok(X2)) -> ok(cons(X1, X2)) , and(ok(X1), ok(X2)) -> ok(and(X1, X2))} using the following strongly linear interpretation: Processor 'Matrix Interpretation' oriented the following rules strictly: {proper^#(cons(X1, X2)) -> c_13(cons^#(proper(X1), proper(X2)))} Details: Interpretation Functions: active(x1) = [0] x1 + [0] zeros() = [0] mark(x1) = [1] x1 + [0] cons(x1, x2) = [1] x1 + [1] x2 + [0] 0() = [0] and(x1, x2) = [1] x1 + [1] x2 + [0] tt() = [0] length(x1) = [1] x1 + [0] nil() = [0] s(x1) = [1] x1 + [0] proper(x1) = [1] x1 + [1] ok(x1) = [1] x1 + [0] top(x1) = [0] x1 + [0] active^#(x1) = [0] x1 + [0] c_0(x1) = [0] x1 + [0] cons^#(x1, x2) = [1] x1 + [1] x2 + [0] c_1() = [0] c_2() = [0] c_3(x1) = [0] x1 + [0] s^#(x1) = [0] x1 + [0] c_4(x1) = [0] x1 + [0] c_5(x1) = [0] x1 + [0] and^#(x1, x2) = [0] x1 + [0] x2 + [0] c_6(x1) = [0] x1 + [0] length^#(x1) = [0] x1 + [0] c_7(x1) = [0] x1 + [0] c_8(x1) = [0] x1 + [0] c_9(x1) = [0] x1 + [0] c_10(x1) = [0] x1 + [0] c_11(x1) = [0] x1 + [0] proper^#(x1) = [1] x1 + [9] c_12() = [0] c_13(x1) = [1] x1 + [1] c_14() = [0] c_15(x1) = [0] x1 + [0] c_16() = [0] c_17(x1) = [0] x1 + [0] c_18() = [0] c_19(x1) = [0] x1 + [0] c_20(x1) = [0] x1 + [0] c_21(x1) = [0] x1 + [0] c_22(x1) = [0] x1 + [0] c_23(x1) = [0] x1 + [0] top^#(x1) = [0] x1 + [0] c_24(x1) = [0] x1 + [0] c_25(x1) = [0] x1 + [0] Finally we apply the subprocessor 'fastest of 'combine', 'Bounds with default enrichment', 'Bounds with default enrichment'' ------------------------------------------------------------------------------------------ Answer: YES(?,O(n^1)) Input Problem: innermost relative runtime-complexity with respect to Strict Rules: { proper(cons(X1, X2)) -> cons(proper(X1), proper(X2)) , proper(and(X1, X2)) -> and(proper(X1), proper(X2)) , proper(length(X)) -> length(proper(X)) , proper(s(X)) -> s(proper(X)) , length(mark(X)) -> mark(length(X)) , length(ok(X)) -> ok(length(X)) , cons(mark(X1), X2) -> mark(cons(X1, X2)) , and(mark(X1), X2) -> mark(and(X1, X2)) , s(mark(X)) -> mark(s(X)) , s(ok(X)) -> ok(s(X))} Weak Rules: { proper^#(cons(X1, X2)) -> c_13(cons^#(proper(X1), proper(X2))) , proper(zeros()) -> ok(zeros()) , proper(0()) -> ok(0()) , proper(tt()) -> ok(tt()) , proper(nil()) -> ok(nil()) , cons(ok(X1), ok(X2)) -> ok(cons(X1, X2)) , and(ok(X1), ok(X2)) -> ok(and(X1, X2))} Details: The problem was solved by processor 'Bounds with default enrichment': 'Bounds with default enrichment' -------------------------------- Answer: YES(?,O(n^1)) Input Problem: innermost relative runtime-complexity with respect to Strict Rules: { proper(cons(X1, X2)) -> cons(proper(X1), proper(X2)) , proper(and(X1, X2)) -> and(proper(X1), proper(X2)) , proper(length(X)) -> length(proper(X)) , proper(s(X)) -> s(proper(X)) , length(mark(X)) -> mark(length(X)) , length(ok(X)) -> ok(length(X)) , cons(mark(X1), X2) -> mark(cons(X1, X2)) , and(mark(X1), X2) -> mark(and(X1, X2)) , s(mark(X)) -> mark(s(X)) , s(ok(X)) -> ok(s(X))} Weak Rules: { proper^#(cons(X1, X2)) -> c_13(cons^#(proper(X1), proper(X2))) , proper(zeros()) -> ok(zeros()) , proper(0()) -> ok(0()) , proper(tt()) -> ok(tt()) , proper(nil()) -> ok(nil()) , cons(ok(X1), ok(X2)) -> ok(cons(X1, X2)) , and(ok(X1), ok(X2)) -> ok(and(X1, X2))} Details: The problem is Match-bounded by 0. The enriched problem is compatible with the following automaton: { zeros_0() -> 2 , mark_0(2) -> 3 , mark_0(3) -> 3 , mark_0(5) -> 3 , mark_0(7) -> 3 , mark_0(9) -> 3 , mark_0(12) -> 3 , 0_0() -> 5 , tt_0() -> 7 , nil_0() -> 9 , ok_0(2) -> 12 , ok_0(3) -> 12 , ok_0(5) -> 12 , ok_0(7) -> 12 , ok_0(9) -> 12 , ok_0(12) -> 12 , cons^#_0(2, 2) -> 16 , cons^#_0(2, 3) -> 16 , cons^#_0(2, 5) -> 16 , cons^#_0(2, 7) -> 16 , cons^#_0(2, 9) -> 16 , cons^#_0(2, 12) -> 16 , cons^#_0(3, 2) -> 16 , cons^#_0(3, 3) -> 16 , cons^#_0(3, 5) -> 16 , cons^#_0(3, 7) -> 16 , cons^#_0(3, 9) -> 16 , cons^#_0(3, 12) -> 16 , cons^#_0(5, 2) -> 16 , cons^#_0(5, 3) -> 16 , cons^#_0(5, 5) -> 16 , cons^#_0(5, 7) -> 16 , cons^#_0(5, 9) -> 16 , cons^#_0(5, 12) -> 16 , cons^#_0(7, 2) -> 16 , cons^#_0(7, 3) -> 16 , cons^#_0(7, 5) -> 16 , cons^#_0(7, 7) -> 16 , cons^#_0(7, 9) -> 16 , cons^#_0(7, 12) -> 16 , cons^#_0(9, 2) -> 16 , cons^#_0(9, 3) -> 16 , cons^#_0(9, 5) -> 16 , cons^#_0(9, 7) -> 16 , cons^#_0(9, 9) -> 16 , cons^#_0(9, 12) -> 16 , cons^#_0(12, 2) -> 16 , cons^#_0(12, 3) -> 16 , cons^#_0(12, 5) -> 16 , cons^#_0(12, 7) -> 16 , cons^#_0(12, 9) -> 16 , cons^#_0(12, 12) -> 16 , proper^#_0(2) -> 31 , proper^#_0(3) -> 31 , proper^#_0(5) -> 31 , proper^#_0(7) -> 31 , proper^#_0(9) -> 31 , proper^#_0(12) -> 31} 16) {proper^#(s(X)) -> c_19(s^#(proper(X)))} The usable rules for this path are the following: { proper(zeros()) -> ok(zeros()) , proper(cons(X1, X2)) -> cons(proper(X1), proper(X2)) , proper(0()) -> ok(0()) , proper(and(X1, X2)) -> and(proper(X1), proper(X2)) , proper(tt()) -> ok(tt()) , proper(length(X)) -> length(proper(X)) , proper(nil()) -> ok(nil()) , proper(s(X)) -> s(proper(X)) , length(mark(X)) -> mark(length(X)) , length(ok(X)) -> ok(length(X)) , cons(mark(X1), X2) -> mark(cons(X1, X2)) , and(mark(X1), X2) -> mark(and(X1, X2)) , s(mark(X)) -> mark(s(X)) , cons(ok(X1), ok(X2)) -> ok(cons(X1, X2)) , and(ok(X1), ok(X2)) -> ok(and(X1, X2)) , s(ok(X)) -> ok(s(X))} We have applied the subprocessor on the union of usable rules and weak (innermost) dependency pairs. 'Weight Gap Principle' ---------------------- Answer: YES(?,O(n^1)) Input Problem: innermost runtime-complexity with respect to Rules: { proper(zeros()) -> ok(zeros()) , proper(cons(X1, X2)) -> cons(proper(X1), proper(X2)) , proper(0()) -> ok(0()) , proper(and(X1, X2)) -> and(proper(X1), proper(X2)) , proper(tt()) -> ok(tt()) , proper(length(X)) -> length(proper(X)) , proper(nil()) -> ok(nil()) , proper(s(X)) -> s(proper(X)) , length(mark(X)) -> mark(length(X)) , length(ok(X)) -> ok(length(X)) , cons(mark(X1), X2) -> mark(cons(X1, X2)) , and(mark(X1), X2) -> mark(and(X1, X2)) , s(mark(X)) -> mark(s(X)) , cons(ok(X1), ok(X2)) -> ok(cons(X1, X2)) , and(ok(X1), ok(X2)) -> ok(and(X1, X2)) , s(ok(X)) -> ok(s(X)) , proper^#(s(X)) -> c_19(s^#(proper(X)))} Details: We apply the weight gap principle, strictly orienting the rules { cons(ok(X1), ok(X2)) -> ok(cons(X1, X2)) , and(ok(X1), ok(X2)) -> ok(and(X1, X2))} and weakly orienting the rules {} using the following strongly linear interpretation: Processor 'Matrix Interpretation' oriented the following rules strictly: { cons(ok(X1), ok(X2)) -> ok(cons(X1, X2)) , and(ok(X1), ok(X2)) -> ok(and(X1, X2))} Details: Interpretation Functions: active(x1) = [0] x1 + [0] zeros() = [0] mark(x1) = [1] x1 + [0] cons(x1, x2) = [1] x1 + [1] x2 + [0] 0() = [0] and(x1, x2) = [1] x1 + [1] x2 + [0] tt() = [0] length(x1) = [1] x1 + [4] nil() = [0] s(x1) = [1] x1 + [0] proper(x1) = [1] x1 + [1] ok(x1) = [1] x1 + [1] top(x1) = [0] x1 + [0] active^#(x1) = [0] x1 + [0] c_0(x1) = [0] x1 + [0] cons^#(x1, x2) = [0] x1 + [0] x2 + [0] c_1() = [0] c_2() = [0] c_3(x1) = [0] x1 + [0] s^#(x1) = [1] x1 + [0] c_4(x1) = [0] x1 + [0] c_5(x1) = [0] x1 + [0] and^#(x1, x2) = [0] x1 + [0] x2 + [0] c_6(x1) = [0] x1 + [0] length^#(x1) = [0] x1 + [0] c_7(x1) = [0] x1 + [0] c_8(x1) = [0] x1 + [0] c_9(x1) = [0] x1 + [0] c_10(x1) = [0] x1 + [0] c_11(x1) = [0] x1 + [0] proper^#(x1) = [1] x1 + [1] c_12() = [0] c_13(x1) = [0] x1 + [0] c_14() = [0] c_15(x1) = [0] x1 + [0] c_16() = [0] c_17(x1) = [0] x1 + [0] c_18() = [0] c_19(x1) = [1] x1 + [0] c_20(x1) = [0] x1 + [0] c_21(x1) = [0] x1 + [0] c_22(x1) = [0] x1 + [0] c_23(x1) = [0] x1 + [0] top^#(x1) = [0] x1 + [0] c_24(x1) = [0] x1 + [0] c_25(x1) = [0] x1 + [0] Finally we apply the subprocessor We apply the weight gap principle, strictly orienting the rules {proper^#(s(X)) -> c_19(s^#(proper(X)))} and weakly orienting the rules { cons(ok(X1), ok(X2)) -> ok(cons(X1, X2)) , and(ok(X1), ok(X2)) -> ok(and(X1, X2))} using the following strongly linear interpretation: Processor 'Matrix Interpretation' oriented the following rules strictly: {proper^#(s(X)) -> c_19(s^#(proper(X)))} Details: Interpretation Functions: active(x1) = [0] x1 + [0] zeros() = [0] mark(x1) = [1] x1 + [0] cons(x1, x2) = [1] x1 + [1] x2 + [0] 0() = [0] and(x1, x2) = [1] x1 + [1] x2 + [0] tt() = [0] length(x1) = [1] x1 + [0] nil() = [0] s(x1) = [1] x1 + [0] proper(x1) = [1] x1 + [1] ok(x1) = [1] x1 + [1] top(x1) = [0] x1 + [0] active^#(x1) = [0] x1 + [0] c_0(x1) = [0] x1 + [0] cons^#(x1, x2) = [0] x1 + [0] x2 + [0] c_1() = [0] c_2() = [0] c_3(x1) = [0] x1 + [0] s^#(x1) = [1] x1 + [0] c_4(x1) = [0] x1 + [0] c_5(x1) = [0] x1 + [0] and^#(x1, x2) = [0] x1 + [0] x2 + [0] c_6(x1) = [0] x1 + [0] length^#(x1) = [0] x1 + [0] c_7(x1) = [0] x1 + [0] c_8(x1) = [0] x1 + [0] c_9(x1) = [0] x1 + [0] c_10(x1) = [0] x1 + [0] c_11(x1) = [0] x1 + [0] proper^#(x1) = [1] x1 + [9] c_12() = [0] c_13(x1) = [0] x1 + [0] c_14() = [0] c_15(x1) = [0] x1 + [0] c_16() = [0] c_17(x1) = [0] x1 + [0] c_18() = [0] c_19(x1) = [1] x1 + [0] c_20(x1) = [0] x1 + [0] c_21(x1) = [0] x1 + [0] c_22(x1) = [0] x1 + [0] c_23(x1) = [0] x1 + [0] top^#(x1) = [0] x1 + [0] c_24(x1) = [0] x1 + [0] c_25(x1) = [0] x1 + [0] Finally we apply the subprocessor We apply the weight gap principle, strictly orienting the rules { proper(zeros()) -> ok(zeros()) , proper(0()) -> ok(0()) , proper(tt()) -> ok(tt()) , proper(nil()) -> ok(nil())} and weakly orienting the rules { proper^#(s(X)) -> c_19(s^#(proper(X))) , cons(ok(X1), ok(X2)) -> ok(cons(X1, X2)) , and(ok(X1), ok(X2)) -> ok(and(X1, X2))} using the following strongly linear interpretation: Processor 'Matrix Interpretation' oriented the following rules strictly: { proper(zeros()) -> ok(zeros()) , proper(0()) -> ok(0()) , proper(tt()) -> ok(tt()) , proper(nil()) -> ok(nil())} Details: Interpretation Functions: active(x1) = [0] x1 + [0] zeros() = [0] mark(x1) = [1] x1 + [0] cons(x1, x2) = [1] x1 + [1] x2 + [0] 0() = [0] and(x1, x2) = [1] x1 + [1] x2 + [0] tt() = [0] length(x1) = [1] x1 + [0] nil() = [0] s(x1) = [1] x1 + [1] proper(x1) = [1] x1 + [1] ok(x1) = [1] x1 + [0] top(x1) = [0] x1 + [0] active^#(x1) = [0] x1 + [0] c_0(x1) = [0] x1 + [0] cons^#(x1, x2) = [0] x1 + [0] x2 + [0] c_1() = [0] c_2() = [0] c_3(x1) = [0] x1 + [0] s^#(x1) = [1] x1 + [1] c_4(x1) = [0] x1 + [0] c_5(x1) = [0] x1 + [0] and^#(x1, x2) = [0] x1 + [0] x2 + [0] c_6(x1) = [0] x1 + [0] length^#(x1) = [0] x1 + [0] c_7(x1) = [0] x1 + [0] c_8(x1) = [0] x1 + [0] c_9(x1) = [0] x1 + [0] c_10(x1) = [0] x1 + [0] c_11(x1) = [0] x1 + [0] proper^#(x1) = [1] x1 + [8] c_12() = [0] c_13(x1) = [0] x1 + [0] c_14() = [0] c_15(x1) = [0] x1 + [0] c_16() = [0] c_17(x1) = [0] x1 + [0] c_18() = [0] c_19(x1) = [1] x1 + [1] c_20(x1) = [0] x1 + [0] c_21(x1) = [0] x1 + [0] c_22(x1) = [0] x1 + [0] c_23(x1) = [0] x1 + [0] top^#(x1) = [0] x1 + [0] c_24(x1) = [0] x1 + [0] c_25(x1) = [0] x1 + [0] Finally we apply the subprocessor 'fastest of 'combine', 'Bounds with default enrichment', 'Bounds with default enrichment'' ------------------------------------------------------------------------------------------ Answer: YES(?,O(n^1)) Input Problem: innermost relative runtime-complexity with respect to Strict Rules: { proper(cons(X1, X2)) -> cons(proper(X1), proper(X2)) , proper(and(X1, X2)) -> and(proper(X1), proper(X2)) , proper(length(X)) -> length(proper(X)) , proper(s(X)) -> s(proper(X)) , length(mark(X)) -> mark(length(X)) , length(ok(X)) -> ok(length(X)) , cons(mark(X1), X2) -> mark(cons(X1, X2)) , and(mark(X1), X2) -> mark(and(X1, X2)) , s(mark(X)) -> mark(s(X)) , s(ok(X)) -> ok(s(X))} Weak Rules: { proper(zeros()) -> ok(zeros()) , proper(0()) -> ok(0()) , proper(tt()) -> ok(tt()) , proper(nil()) -> ok(nil()) , proper^#(s(X)) -> c_19(s^#(proper(X))) , cons(ok(X1), ok(X2)) -> ok(cons(X1, X2)) , and(ok(X1), ok(X2)) -> ok(and(X1, X2))} Details: The problem was solved by processor 'Bounds with default enrichment': 'Bounds with default enrichment' -------------------------------- Answer: YES(?,O(n^1)) Input Problem: innermost relative runtime-complexity with respect to Strict Rules: { proper(cons(X1, X2)) -> cons(proper(X1), proper(X2)) , proper(and(X1, X2)) -> and(proper(X1), proper(X2)) , proper(length(X)) -> length(proper(X)) , proper(s(X)) -> s(proper(X)) , length(mark(X)) -> mark(length(X)) , length(ok(X)) -> ok(length(X)) , cons(mark(X1), X2) -> mark(cons(X1, X2)) , and(mark(X1), X2) -> mark(and(X1, X2)) , s(mark(X)) -> mark(s(X)) , s(ok(X)) -> ok(s(X))} Weak Rules: { proper(zeros()) -> ok(zeros()) , proper(0()) -> ok(0()) , proper(tt()) -> ok(tt()) , proper(nil()) -> ok(nil()) , proper^#(s(X)) -> c_19(s^#(proper(X))) , cons(ok(X1), ok(X2)) -> ok(cons(X1, X2)) , and(ok(X1), ok(X2)) -> ok(and(X1, X2))} Details: The problem is Match-bounded by 0. The enriched problem is compatible with the following automaton: { zeros_0() -> 2 , mark_0(2) -> 3 , mark_0(3) -> 3 , mark_0(5) -> 3 , mark_0(7) -> 3 , mark_0(9) -> 3 , mark_0(12) -> 3 , 0_0() -> 5 , tt_0() -> 7 , nil_0() -> 9 , ok_0(2) -> 12 , ok_0(3) -> 12 , ok_0(5) -> 12 , ok_0(7) -> 12 , ok_0(9) -> 12 , ok_0(12) -> 12 , s^#_0(2) -> 20 , s^#_0(3) -> 20 , s^#_0(5) -> 20 , s^#_0(7) -> 20 , s^#_0(9) -> 20 , s^#_0(12) -> 20 , proper^#_0(2) -> 31 , proper^#_0(3) -> 31 , proper^#_0(5) -> 31 , proper^#_0(7) -> 31 , proper^#_0(9) -> 31 , proper^#_0(12) -> 31} 17) {proper^#(length(X)) -> c_17(length^#(proper(X)))} The usable rules for this path are the following: { proper(zeros()) -> ok(zeros()) , proper(cons(X1, X2)) -> cons(proper(X1), proper(X2)) , proper(0()) -> ok(0()) , proper(and(X1, X2)) -> and(proper(X1), proper(X2)) , proper(tt()) -> ok(tt()) , proper(length(X)) -> length(proper(X)) , proper(nil()) -> ok(nil()) , proper(s(X)) -> s(proper(X)) , length(mark(X)) -> mark(length(X)) , length(ok(X)) -> ok(length(X)) , cons(mark(X1), X2) -> mark(cons(X1, X2)) , and(mark(X1), X2) -> mark(and(X1, X2)) , s(mark(X)) -> mark(s(X)) , cons(ok(X1), ok(X2)) -> ok(cons(X1, X2)) , and(ok(X1), ok(X2)) -> ok(and(X1, X2)) , s(ok(X)) -> ok(s(X))} We have applied the subprocessor on the union of usable rules and weak (innermost) dependency pairs. 'Weight Gap Principle' ---------------------- Answer: YES(?,O(n^1)) Input Problem: innermost runtime-complexity with respect to Rules: { proper(zeros()) -> ok(zeros()) , proper(cons(X1, X2)) -> cons(proper(X1), proper(X2)) , proper(0()) -> ok(0()) , proper(and(X1, X2)) -> and(proper(X1), proper(X2)) , proper(tt()) -> ok(tt()) , proper(length(X)) -> length(proper(X)) , proper(nil()) -> ok(nil()) , proper(s(X)) -> s(proper(X)) , length(mark(X)) -> mark(length(X)) , length(ok(X)) -> ok(length(X)) , cons(mark(X1), X2) -> mark(cons(X1, X2)) , and(mark(X1), X2) -> mark(and(X1, X2)) , s(mark(X)) -> mark(s(X)) , cons(ok(X1), ok(X2)) -> ok(cons(X1, X2)) , and(ok(X1), ok(X2)) -> ok(and(X1, X2)) , s(ok(X)) -> ok(s(X)) , proper^#(length(X)) -> c_17(length^#(proper(X)))} Details: We apply the weight gap principle, strictly orienting the rules { cons(ok(X1), ok(X2)) -> ok(cons(X1, X2)) , and(ok(X1), ok(X2)) -> ok(and(X1, X2)) , proper^#(length(X)) -> c_17(length^#(proper(X)))} and weakly orienting the rules {} using the following strongly linear interpretation: Processor 'Matrix Interpretation' oriented the following rules strictly: { cons(ok(X1), ok(X2)) -> ok(cons(X1, X2)) , and(ok(X1), ok(X2)) -> ok(and(X1, X2)) , proper^#(length(X)) -> c_17(length^#(proper(X)))} Details: Interpretation Functions: active(x1) = [0] x1 + [0] zeros() = [0] mark(x1) = [1] x1 + [4] cons(x1, x2) = [1] x1 + [1] x2 + [0] 0() = [0] and(x1, x2) = [1] x1 + [1] x2 + [0] tt() = [0] length(x1) = [1] x1 + [4] nil() = [0] s(x1) = [1] x1 + [0] proper(x1) = [1] x1 + [1] ok(x1) = [1] x1 + [1] top(x1) = [0] x1 + [0] active^#(x1) = [0] x1 + [0] c_0(x1) = [0] x1 + [0] cons^#(x1, x2) = [0] x1 + [0] x2 + [0] c_1() = [0] c_2() = [0] c_3(x1) = [0] x1 + [0] s^#(x1) = [0] x1 + [0] c_4(x1) = [0] x1 + [0] c_5(x1) = [0] x1 + [0] and^#(x1, x2) = [0] x1 + [0] x2 + [0] c_6(x1) = [0] x1 + [0] length^#(x1) = [1] x1 + [0] c_7(x1) = [0] x1 + [0] c_8(x1) = [0] x1 + [0] c_9(x1) = [0] x1 + [0] c_10(x1) = [0] x1 + [0] c_11(x1) = [0] x1 + [0] proper^#(x1) = [1] x1 + [1] c_12() = [0] c_13(x1) = [0] x1 + [0] c_14() = [0] c_15(x1) = [0] x1 + [0] c_16() = [0] c_17(x1) = [1] x1 + [0] c_18() = [0] c_19(x1) = [0] x1 + [0] c_20(x1) = [0] x1 + [0] c_21(x1) = [0] x1 + [0] c_22(x1) = [0] x1 + [0] c_23(x1) = [0] x1 + [0] top^#(x1) = [0] x1 + [0] c_24(x1) = [0] x1 + [0] c_25(x1) = [0] x1 + [0] Finally we apply the subprocessor We apply the weight gap principle, strictly orienting the rules { proper(zeros()) -> ok(zeros()) , proper(0()) -> ok(0()) , proper(tt()) -> ok(tt()) , proper(nil()) -> ok(nil())} and weakly orienting the rules { cons(ok(X1), ok(X2)) -> ok(cons(X1, X2)) , and(ok(X1), ok(X2)) -> ok(and(X1, X2)) , proper^#(length(X)) -> c_17(length^#(proper(X)))} using the following strongly linear interpretation: Processor 'Matrix Interpretation' oriented the following rules strictly: { proper(zeros()) -> ok(zeros()) , proper(0()) -> ok(0()) , proper(tt()) -> ok(tt()) , proper(nil()) -> ok(nil())} Details: Interpretation Functions: active(x1) = [0] x1 + [0] zeros() = [0] mark(x1) = [1] x1 + [0] cons(x1, x2) = [1] x1 + [1] x2 + [0] 0() = [0] and(x1, x2) = [1] x1 + [1] x2 + [1] tt() = [0] length(x1) = [1] x1 + [0] nil() = [0] s(x1) = [1] x1 + [0] proper(x1) = [1] x1 + [1] ok(x1) = [1] x1 + [0] top(x1) = [0] x1 + [0] active^#(x1) = [0] x1 + [0] c_0(x1) = [0] x1 + [0] cons^#(x1, x2) = [0] x1 + [0] x2 + [0] c_1() = [0] c_2() = [0] c_3(x1) = [0] x1 + [0] s^#(x1) = [0] x1 + [0] c_4(x1) = [0] x1 + [0] c_5(x1) = [0] x1 + [0] and^#(x1, x2) = [0] x1 + [0] x2 + [0] c_6(x1) = [0] x1 + [0] length^#(x1) = [1] x1 + [0] c_7(x1) = [0] x1 + [0] c_8(x1) = [0] x1 + [0] c_9(x1) = [0] x1 + [0] c_10(x1) = [0] x1 + [0] c_11(x1) = [0] x1 + [0] proper^#(x1) = [1] x1 + [8] c_12() = [0] c_13(x1) = [0] x1 + [0] c_14() = [0] c_15(x1) = [0] x1 + [0] c_16() = [0] c_17(x1) = [1] x1 + [0] c_18() = [0] c_19(x1) = [0] x1 + [0] c_20(x1) = [0] x1 + [0] c_21(x1) = [0] x1 + [0] c_22(x1) = [0] x1 + [0] c_23(x1) = [0] x1 + [0] top^#(x1) = [0] x1 + [0] c_24(x1) = [0] x1 + [0] c_25(x1) = [0] x1 + [0] Finally we apply the subprocessor 'fastest of 'combine', 'Bounds with default enrichment', 'Bounds with default enrichment'' ------------------------------------------------------------------------------------------ Answer: YES(?,O(n^1)) Input Problem: innermost relative runtime-complexity with respect to Strict Rules: { proper(cons(X1, X2)) -> cons(proper(X1), proper(X2)) , proper(and(X1, X2)) -> and(proper(X1), proper(X2)) , proper(length(X)) -> length(proper(X)) , proper(s(X)) -> s(proper(X)) , length(mark(X)) -> mark(length(X)) , length(ok(X)) -> ok(length(X)) , cons(mark(X1), X2) -> mark(cons(X1, X2)) , and(mark(X1), X2) -> mark(and(X1, X2)) , s(mark(X)) -> mark(s(X)) , s(ok(X)) -> ok(s(X))} Weak Rules: { proper(zeros()) -> ok(zeros()) , proper(0()) -> ok(0()) , proper(tt()) -> ok(tt()) , proper(nil()) -> ok(nil()) , cons(ok(X1), ok(X2)) -> ok(cons(X1, X2)) , and(ok(X1), ok(X2)) -> ok(and(X1, X2)) , proper^#(length(X)) -> c_17(length^#(proper(X)))} Details: The problem was solved by processor 'Bounds with default enrichment': 'Bounds with default enrichment' -------------------------------- Answer: YES(?,O(n^1)) Input Problem: innermost relative runtime-complexity with respect to Strict Rules: { proper(cons(X1, X2)) -> cons(proper(X1), proper(X2)) , proper(and(X1, X2)) -> and(proper(X1), proper(X2)) , proper(length(X)) -> length(proper(X)) , proper(s(X)) -> s(proper(X)) , length(mark(X)) -> mark(length(X)) , length(ok(X)) -> ok(length(X)) , cons(mark(X1), X2) -> mark(cons(X1, X2)) , and(mark(X1), X2) -> mark(and(X1, X2)) , s(mark(X)) -> mark(s(X)) , s(ok(X)) -> ok(s(X))} Weak Rules: { proper(zeros()) -> ok(zeros()) , proper(0()) -> ok(0()) , proper(tt()) -> ok(tt()) , proper(nil()) -> ok(nil()) , cons(ok(X1), ok(X2)) -> ok(cons(X1, X2)) , and(ok(X1), ok(X2)) -> ok(and(X1, X2)) , proper^#(length(X)) -> c_17(length^#(proper(X)))} Details: The problem is Match-bounded by 0. The enriched problem is compatible with the following automaton: { zeros_0() -> 2 , mark_0(2) -> 3 , mark_0(3) -> 3 , mark_0(5) -> 3 , mark_0(7) -> 3 , mark_0(9) -> 3 , mark_0(12) -> 3 , 0_0() -> 5 , tt_0() -> 7 , nil_0() -> 9 , ok_0(2) -> 12 , ok_0(3) -> 12 , ok_0(5) -> 12 , ok_0(7) -> 12 , ok_0(9) -> 12 , ok_0(12) -> 12 , length^#_0(2) -> 25 , length^#_0(3) -> 25 , length^#_0(5) -> 25 , length^#_0(7) -> 25 , length^#_0(9) -> 25 , length^#_0(12) -> 25 , proper^#_0(2) -> 31 , proper^#_0(3) -> 31 , proper^#_0(5) -> 31 , proper^#_0(7) -> 31 , proper^#_0(9) -> 31 , proper^#_0(12) -> 31} 18) { active^#(length(cons(N, L))) -> c_3(s^#(length(L))) , s^#(ok(X)) -> c_23(s^#(X)) , s^#(mark(X)) -> c_11(s^#(X))} The usable rules for this path are the following: { length(mark(X)) -> mark(length(X)) , length(ok(X)) -> ok(length(X))} We have applied the subprocessor on the union of usable rules and weak (innermost) dependency pairs. 'Weight Gap Principle' ---------------------- Answer: YES(?,O(n^1)) Input Problem: innermost runtime-complexity with respect to Rules: { length(mark(X)) -> mark(length(X)) , length(ok(X)) -> ok(length(X)) , active^#(length(cons(N, L))) -> c_3(s^#(length(L))) , s^#(ok(X)) -> c_23(s^#(X)) , s^#(mark(X)) -> c_11(s^#(X))} Details: We apply the weight gap principle, strictly orienting the rules {active^#(length(cons(N, L))) -> c_3(s^#(length(L)))} and weakly orienting the rules {} using the following strongly linear interpretation: Processor 'Matrix Interpretation' oriented the following rules strictly: {active^#(length(cons(N, L))) -> c_3(s^#(length(L)))} Details: Interpretation Functions: active(x1) = [0] x1 + [0] zeros() = [0] mark(x1) = [1] x1 + [0] cons(x1, x2) = [1] x1 + [1] x2 + [0] 0() = [0] and(x1, x2) = [0] x1 + [0] x2 + [0] tt() = [0] length(x1) = [1] x1 + [1] nil() = [0] s(x1) = [0] x1 + [0] proper(x1) = [0] x1 + [0] ok(x1) = [1] x1 + [0] top(x1) = [0] x1 + [0] active^#(x1) = [1] x1 + [8] c_0(x1) = [0] x1 + [0] cons^#(x1, x2) = [0] x1 + [0] x2 + [0] c_1() = [0] c_2() = [0] c_3(x1) = [1] x1 + [0] s^#(x1) = [1] x1 + [0] c_4(x1) = [0] x1 + [0] c_5(x1) = [0] x1 + [0] and^#(x1, x2) = [0] x1 + [0] x2 + [0] c_6(x1) = [0] x1 + [0] length^#(x1) = [0] x1 + [0] c_7(x1) = [0] x1 + [0] c_8(x1) = [0] x1 + [0] c_9(x1) = [0] x1 + [0] c_10(x1) = [0] x1 + [0] c_11(x1) = [1] x1 + [0] proper^#(x1) = [0] x1 + [0] c_12() = [0] c_13(x1) = [0] x1 + [0] c_14() = [0] c_15(x1) = [0] x1 + [0] c_16() = [0] c_17(x1) = [0] x1 + [0] c_18() = [0] c_19(x1) = [0] x1 + [0] c_20(x1) = [0] x1 + [0] c_21(x1) = [0] x1 + [0] c_22(x1) = [0] x1 + [0] c_23(x1) = [1] x1 + [2] top^#(x1) = [0] x1 + [0] c_24(x1) = [0] x1 + [0] c_25(x1) = [0] x1 + [0] Finally we apply the subprocessor We apply the weight gap principle, strictly orienting the rules {s^#(ok(X)) -> c_23(s^#(X))} and weakly orienting the rules {active^#(length(cons(N, L))) -> c_3(s^#(length(L)))} using the following strongly linear interpretation: Processor 'Matrix Interpretation' oriented the following rules strictly: {s^#(ok(X)) -> c_23(s^#(X))} Details: Interpretation Functions: active(x1) = [0] x1 + [0] zeros() = [0] mark(x1) = [1] x1 + [0] cons(x1, x2) = [1] x1 + [1] x2 + [5] 0() = [0] and(x1, x2) = [0] x1 + [0] x2 + [0] tt() = [0] length(x1) = [1] x1 + [1] nil() = [0] s(x1) = [0] x1 + [0] proper(x1) = [0] x1 + [0] ok(x1) = [1] x1 + [8] top(x1) = [0] x1 + [0] active^#(x1) = [1] x1 + [12] c_0(x1) = [0] x1 + [0] cons^#(x1, x2) = [0] x1 + [0] x2 + [0] c_1() = [0] c_2() = [0] c_3(x1) = [1] x1 + [0] s^#(x1) = [1] x1 + [0] c_4(x1) = [0] x1 + [0] c_5(x1) = [0] x1 + [0] and^#(x1, x2) = [0] x1 + [0] x2 + [0] c_6(x1) = [0] x1 + [0] length^#(x1) = [0] x1 + [0] c_7(x1) = [0] x1 + [0] c_8(x1) = [0] x1 + [0] c_9(x1) = [0] x1 + [0] c_10(x1) = [0] x1 + [0] c_11(x1) = [1] x1 + [0] proper^#(x1) = [0] x1 + [0] c_12() = [0] c_13(x1) = [0] x1 + [0] c_14() = [0] c_15(x1) = [0] x1 + [0] c_16() = [0] c_17(x1) = [0] x1 + [0] c_18() = [0] c_19(x1) = [0] x1 + [0] c_20(x1) = [0] x1 + [0] c_21(x1) = [0] x1 + [0] c_22(x1) = [0] x1 + [0] c_23(x1) = [1] x1 + [0] top^#(x1) = [0] x1 + [0] c_24(x1) = [0] x1 + [0] c_25(x1) = [0] x1 + [0] Finally we apply the subprocessor We apply the weight gap principle, strictly orienting the rules {s^#(mark(X)) -> c_11(s^#(X))} and weakly orienting the rules { s^#(ok(X)) -> c_23(s^#(X)) , active^#(length(cons(N, L))) -> c_3(s^#(length(L)))} using the following strongly linear interpretation: Processor 'Matrix Interpretation' oriented the following rules strictly: {s^#(mark(X)) -> c_11(s^#(X))} Details: Interpretation Functions: active(x1) = [0] x1 + [0] zeros() = [0] mark(x1) = [1] x1 + [8] cons(x1, x2) = [1] x1 + [1] x2 + [15] 0() = [0] and(x1, x2) = [0] x1 + [0] x2 + [0] tt() = [0] length(x1) = [1] x1 + [1] nil() = [0] s(x1) = [0] x1 + [0] proper(x1) = [0] x1 + [0] ok(x1) = [1] x1 + [0] top(x1) = [0] x1 + [0] active^#(x1) = [1] x1 + [0] c_0(x1) = [0] x1 + [0] cons^#(x1, x2) = [0] x1 + [0] x2 + [0] c_1() = [0] c_2() = [0] c_3(x1) = [1] x1 + [0] s^#(x1) = [1] x1 + [4] c_4(x1) = [0] x1 + [0] c_5(x1) = [0] x1 + [0] and^#(x1, x2) = [0] x1 + [0] x2 + [0] c_6(x1) = [0] x1 + [0] length^#(x1) = [0] x1 + [0] c_7(x1) = [0] x1 + [0] c_8(x1) = [0] x1 + [0] c_9(x1) = [0] x1 + [0] c_10(x1) = [0] x1 + [0] c_11(x1) = [1] x1 + [4] proper^#(x1) = [0] x1 + [0] c_12() = [0] c_13(x1) = [0] x1 + [0] c_14() = [0] c_15(x1) = [0] x1 + [0] c_16() = [0] c_17(x1) = [0] x1 + [0] c_18() = [0] c_19(x1) = [0] x1 + [0] c_20(x1) = [0] x1 + [0] c_21(x1) = [0] x1 + [0] c_22(x1) = [0] x1 + [0] c_23(x1) = [1] x1 + [0] top^#(x1) = [0] x1 + [0] c_24(x1) = [0] x1 + [0] c_25(x1) = [0] x1 + [0] Finally we apply the subprocessor 'fastest of 'combine', 'Bounds with default enrichment', 'Bounds with default enrichment'' ------------------------------------------------------------------------------------------ Answer: YES(?,O(n^1)) Input Problem: innermost relative runtime-complexity with respect to Strict Rules: { length(mark(X)) -> mark(length(X)) , length(ok(X)) -> ok(length(X))} Weak Rules: { s^#(mark(X)) -> c_11(s^#(X)) , s^#(ok(X)) -> c_23(s^#(X)) , active^#(length(cons(N, L))) -> c_3(s^#(length(L)))} Details: The problem was solved by processor 'Bounds with default enrichment': 'Bounds with default enrichment' -------------------------------- Answer: YES(?,O(n^1)) Input Problem: innermost relative runtime-complexity with respect to Strict Rules: { length(mark(X)) -> mark(length(X)) , length(ok(X)) -> ok(length(X))} Weak Rules: { s^#(mark(X)) -> c_11(s^#(X)) , s^#(ok(X)) -> c_23(s^#(X)) , active^#(length(cons(N, L))) -> c_3(s^#(length(L)))} Details: The problem is Match-bounded by 0. The enriched problem is compatible with the following automaton: { mark_0(3) -> 3 , mark_0(12) -> 3 , ok_0(3) -> 12 , ok_0(12) -> 12 , active^#_0(3) -> 14 , active^#_0(12) -> 14 , s^#_0(3) -> 20 , s^#_0(12) -> 20 , c_11_0(20) -> 20 , c_23_0(20) -> 20} 19) {active^#(length(cons(N, L))) -> c_3(s^#(length(L)))} The usable rules for this path are the following: { length(mark(X)) -> mark(length(X)) , length(ok(X)) -> ok(length(X))} We have applied the subprocessor on the union of usable rules and weak (innermost) dependency pairs. 'Weight Gap Principle' ---------------------- Answer: YES(?,O(n^1)) Input Problem: innermost runtime-complexity with respect to Rules: { length(mark(X)) -> mark(length(X)) , length(ok(X)) -> ok(length(X)) , active^#(length(cons(N, L))) -> c_3(s^#(length(L)))} Details: We apply the weight gap principle, strictly orienting the rules {active^#(length(cons(N, L))) -> c_3(s^#(length(L)))} and weakly orienting the rules {} using the following strongly linear interpretation: Processor 'Matrix Interpretation' oriented the following rules strictly: {active^#(length(cons(N, L))) -> c_3(s^#(length(L)))} Details: Interpretation Functions: active(x1) = [0] x1 + [0] zeros() = [0] mark(x1) = [1] x1 + [0] cons(x1, x2) = [1] x1 + [1] x2 + [0] 0() = [0] and(x1, x2) = [0] x1 + [0] x2 + [0] tt() = [0] length(x1) = [1] x1 + [1] nil() = [0] s(x1) = [0] x1 + [0] proper(x1) = [0] x1 + [0] ok(x1) = [1] x1 + [0] top(x1) = [0] x1 + [0] active^#(x1) = [1] x1 + [8] c_0(x1) = [0] x1 + [0] cons^#(x1, x2) = [0] x1 + [0] x2 + [0] c_1() = [0] c_2() = [0] c_3(x1) = [1] x1 + [1] s^#(x1) = [1] x1 + [0] c_4(x1) = [0] x1 + [0] c_5(x1) = [0] x1 + [0] and^#(x1, x2) = [0] x1 + [0] x2 + [0] c_6(x1) = [0] x1 + [0] length^#(x1) = [0] x1 + [0] c_7(x1) = [0] x1 + [0] c_8(x1) = [0] x1 + [0] c_9(x1) = [0] x1 + [0] c_10(x1) = [0] x1 + [0] c_11(x1) = [0] x1 + [0] proper^#(x1) = [0] x1 + [0] c_12() = [0] c_13(x1) = [0] x1 + [0] c_14() = [0] c_15(x1) = [0] x1 + [0] c_16() = [0] c_17(x1) = [0] x1 + [0] c_18() = [0] c_19(x1) = [0] x1 + [0] c_20(x1) = [0] x1 + [0] c_21(x1) = [0] x1 + [0] c_22(x1) = [0] x1 + [0] c_23(x1) = [0] x1 + [0] top^#(x1) = [0] x1 + [0] c_24(x1) = [0] x1 + [0] c_25(x1) = [0] x1 + [0] Finally we apply the subprocessor 'fastest of 'combine', 'Bounds with default enrichment', 'Bounds with default enrichment'' ------------------------------------------------------------------------------------------ Answer: YES(?,O(n^1)) Input Problem: innermost relative runtime-complexity with respect to Strict Rules: { length(mark(X)) -> mark(length(X)) , length(ok(X)) -> ok(length(X))} Weak Rules: {active^#(length(cons(N, L))) -> c_3(s^#(length(L)))} Details: The problem was solved by processor 'Bounds with default enrichment': 'Bounds with default enrichment' -------------------------------- Answer: YES(?,O(n^1)) Input Problem: innermost relative runtime-complexity with respect to Strict Rules: { length(mark(X)) -> mark(length(X)) , length(ok(X)) -> ok(length(X))} Weak Rules: {active^#(length(cons(N, L))) -> c_3(s^#(length(L)))} Details: The problem is Match-bounded by 0. The enriched problem is compatible with the following automaton: { mark_0(3) -> 3 , mark_0(12) -> 3 , ok_0(3) -> 12 , ok_0(12) -> 12 , active^#_0(3) -> 14 , active^#_0(12) -> 14 , s^#_0(3) -> 20 , s^#_0(12) -> 20} 20) {active^#(zeros()) -> c_0(cons^#(0(), zeros()))} The usable rules for this path are empty. We have oriented the usable rules with the following strongly linear interpretation: Interpretation Functions: active(x1) = [0] x1 + [0] zeros() = [0] mark(x1) = [0] x1 + [0] cons(x1, x2) = [0] x1 + [0] x2 + [0] 0() = [0] and(x1, x2) = [0] x1 + [0] x2 + [0] tt() = [0] length(x1) = [0] x1 + [0] nil() = [0] s(x1) = [0] x1 + [0] proper(x1) = [0] x1 + [0] ok(x1) = [0] x1 + [0] top(x1) = [0] x1 + [0] active^#(x1) = [0] x1 + [0] c_0(x1) = [0] x1 + [0] cons^#(x1, x2) = [0] x1 + [0] x2 + [0] c_1() = [0] c_2() = [0] c_3(x1) = [0] x1 + [0] s^#(x1) = [0] x1 + [0] c_4(x1) = [0] x1 + [0] c_5(x1) = [0] x1 + [0] and^#(x1, x2) = [0] x1 + [0] x2 + [0] c_6(x1) = [0] x1 + [0] length^#(x1) = [0] x1 + [0] c_7(x1) = [0] x1 + [0] c_8(x1) = [0] x1 + [0] c_9(x1) = [0] x1 + [0] c_10(x1) = [0] x1 + [0] c_11(x1) = [0] x1 + [0] proper^#(x1) = [0] x1 + [0] c_12() = [0] c_13(x1) = [0] x1 + [0] c_14() = [0] c_15(x1) = [0] x1 + [0] c_16() = [0] c_17(x1) = [0] x1 + [0] c_18() = [0] c_19(x1) = [0] x1 + [0] c_20(x1) = [0] x1 + [0] c_21(x1) = [0] x1 + [0] c_22(x1) = [0] x1 + [0] c_23(x1) = [0] x1 + [0] top^#(x1) = [0] x1 + [0] c_24(x1) = [0] x1 + [0] c_25(x1) = [0] x1 + [0] We have applied the subprocessor on the resulting DP-problem: 'Weight Gap Principle' ---------------------- Answer: YES(?,O(n^1)) Input Problem: innermost DP runtime-complexity with respect to Strict Rules: {active^#(zeros()) -> c_0(cons^#(0(), zeros()))} Weak Rules: {} Details: We apply the weight gap principle, strictly orienting the rules {active^#(zeros()) -> c_0(cons^#(0(), zeros()))} and weakly orienting the rules {} using the following strongly linear interpretation: Processor 'Matrix Interpretation' oriented the following rules strictly: {active^#(zeros()) -> c_0(cons^#(0(), zeros()))} Details: Interpretation Functions: active(x1) = [0] x1 + [0] zeros() = [0] mark(x1) = [0] x1 + [0] cons(x1, x2) = [0] x1 + [0] x2 + [0] 0() = [0] and(x1, x2) = [0] x1 + [0] x2 + [0] tt() = [0] length(x1) = [0] x1 + [0] nil() = [0] s(x1) = [0] x1 + [0] proper(x1) = [0] x1 + [0] ok(x1) = [0] x1 + [0] top(x1) = [0] x1 + [0] active^#(x1) = [1] x1 + [1] c_0(x1) = [1] x1 + [0] cons^#(x1, x2) = [1] x1 + [1] x2 + [0] c_1() = [0] c_2() = [0] c_3(x1) = [0] x1 + [0] s^#(x1) = [0] x1 + [0] c_4(x1) = [0] x1 + [0] c_5(x1) = [0] x1 + [0] and^#(x1, x2) = [0] x1 + [0] x2 + [0] c_6(x1) = [0] x1 + [0] length^#(x1) = [0] x1 + [0] c_7(x1) = [0] x1 + [0] c_8(x1) = [0] x1 + [0] c_9(x1) = [0] x1 + [0] c_10(x1) = [0] x1 + [0] c_11(x1) = [0] x1 + [0] proper^#(x1) = [0] x1 + [0] c_12() = [0] c_13(x1) = [0] x1 + [0] c_14() = [0] c_15(x1) = [0] x1 + [0] c_16() = [0] c_17(x1) = [0] x1 + [0] c_18() = [0] c_19(x1) = [0] x1 + [0] c_20(x1) = [0] x1 + [0] c_21(x1) = [0] x1 + [0] c_22(x1) = [0] x1 + [0] c_23(x1) = [0] x1 + [0] top^#(x1) = [0] x1 + [0] c_24(x1) = [0] x1 + [0] c_25(x1) = [0] x1 + [0] Finally we apply the subprocessor 'Empty TRS' ----------- Answer: YES(?,O(1)) Input Problem: innermost DP runtime-complexity with respect to Strict Rules: {} Weak Rules: {active^#(zeros()) -> c_0(cons^#(0(), zeros()))} Details: The given problem does not contain any strict rules 21) {active^#(length(nil())) -> c_2()} The usable rules for this path are empty. We have oriented the usable rules with the following strongly linear interpretation: Interpretation Functions: active(x1) = [0] x1 + [0] zeros() = [0] mark(x1) = [0] x1 + [0] cons(x1, x2) = [0] x1 + [0] x2 + [0] 0() = [0] and(x1, x2) = [0] x1 + [0] x2 + [0] tt() = [0] length(x1) = [0] x1 + [0] nil() = [0] s(x1) = [0] x1 + [0] proper(x1) = [0] x1 + [0] ok(x1) = [0] x1 + [0] top(x1) = [0] x1 + [0] active^#(x1) = [0] x1 + [0] c_0(x1) = [0] x1 + [0] cons^#(x1, x2) = [0] x1 + [0] x2 + [0] c_1() = [0] c_2() = [0] c_3(x1) = [0] x1 + [0] s^#(x1) = [0] x1 + [0] c_4(x1) = [0] x1 + [0] c_5(x1) = [0] x1 + [0] and^#(x1, x2) = [0] x1 + [0] x2 + [0] c_6(x1) = [0] x1 + [0] length^#(x1) = [0] x1 + [0] c_7(x1) = [0] x1 + [0] c_8(x1) = [0] x1 + [0] c_9(x1) = [0] x1 + [0] c_10(x1) = [0] x1 + [0] c_11(x1) = [0] x1 + [0] proper^#(x1) = [0] x1 + [0] c_12() = [0] c_13(x1) = [0] x1 + [0] c_14() = [0] c_15(x1) = [0] x1 + [0] c_16() = [0] c_17(x1) = [0] x1 + [0] c_18() = [0] c_19(x1) = [0] x1 + [0] c_20(x1) = [0] x1 + [0] c_21(x1) = [0] x1 + [0] c_22(x1) = [0] x1 + [0] c_23(x1) = [0] x1 + [0] top^#(x1) = [0] x1 + [0] c_24(x1) = [0] x1 + [0] c_25(x1) = [0] x1 + [0] We have applied the subprocessor on the resulting DP-problem: 'Weight Gap Principle' ---------------------- Answer: YES(?,O(n^1)) Input Problem: innermost DP runtime-complexity with respect to Strict Rules: {active^#(length(nil())) -> c_2()} Weak Rules: {} Details: We apply the weight gap principle, strictly orienting the rules {active^#(length(nil())) -> c_2()} and weakly orienting the rules {} using the following strongly linear interpretation: Processor 'Matrix Interpretation' oriented the following rules strictly: {active^#(length(nil())) -> c_2()} Details: Interpretation Functions: active(x1) = [0] x1 + [0] zeros() = [0] mark(x1) = [0] x1 + [0] cons(x1, x2) = [0] x1 + [0] x2 + [0] 0() = [0] and(x1, x2) = [0] x1 + [0] x2 + [0] tt() = [0] length(x1) = [1] x1 + [0] nil() = [0] s(x1) = [0] x1 + [0] proper(x1) = [0] x1 + [0] ok(x1) = [0] x1 + [0] top(x1) = [0] x1 + [0] active^#(x1) = [1] x1 + [1] c_0(x1) = [0] x1 + [0] cons^#(x1, x2) = [0] x1 + [0] x2 + [0] c_1() = [0] c_2() = [0] c_3(x1) = [0] x1 + [0] s^#(x1) = [0] x1 + [0] c_4(x1) = [0] x1 + [0] c_5(x1) = [0] x1 + [0] and^#(x1, x2) = [0] x1 + [0] x2 + [0] c_6(x1) = [0] x1 + [0] length^#(x1) = [0] x1 + [0] c_7(x1) = [0] x1 + [0] c_8(x1) = [0] x1 + [0] c_9(x1) = [0] x1 + [0] c_10(x1) = [0] x1 + [0] c_11(x1) = [0] x1 + [0] proper^#(x1) = [0] x1 + [0] c_12() = [0] c_13(x1) = [0] x1 + [0] c_14() = [0] c_15(x1) = [0] x1 + [0] c_16() = [0] c_17(x1) = [0] x1 + [0] c_18() = [0] c_19(x1) = [0] x1 + [0] c_20(x1) = [0] x1 + [0] c_21(x1) = [0] x1 + [0] c_22(x1) = [0] x1 + [0] c_23(x1) = [0] x1 + [0] top^#(x1) = [0] x1 + [0] c_24(x1) = [0] x1 + [0] c_25(x1) = [0] x1 + [0] Finally we apply the subprocessor 'Empty TRS' ----------- Answer: YES(?,O(1)) Input Problem: innermost DP runtime-complexity with respect to Strict Rules: {} Weak Rules: {active^#(length(nil())) -> c_2()} Details: The given problem does not contain any strict rules 22) {active^#(and(tt(), X)) -> c_1()} The usable rules for this path are empty. We have oriented the usable rules with the following strongly linear interpretation: Interpretation Functions: active(x1) = [0] x1 + [0] zeros() = [0] mark(x1) = [0] x1 + [0] cons(x1, x2) = [0] x1 + [0] x2 + [0] 0() = [0] and(x1, x2) = [0] x1 + [0] x2 + [0] tt() = [0] length(x1) = [0] x1 + [0] nil() = [0] s(x1) = [0] x1 + [0] proper(x1) = [0] x1 + [0] ok(x1) = [0] x1 + [0] top(x1) = [0] x1 + [0] active^#(x1) = [0] x1 + [0] c_0(x1) = [0] x1 + [0] cons^#(x1, x2) = [0] x1 + [0] x2 + [0] c_1() = [0] c_2() = [0] c_3(x1) = [0] x1 + [0] s^#(x1) = [0] x1 + [0] c_4(x1) = [0] x1 + [0] c_5(x1) = [0] x1 + [0] and^#(x1, x2) = [0] x1 + [0] x2 + [0] c_6(x1) = [0] x1 + [0] length^#(x1) = [0] x1 + [0] c_7(x1) = [0] x1 + [0] c_8(x1) = [0] x1 + [0] c_9(x1) = [0] x1 + [0] c_10(x1) = [0] x1 + [0] c_11(x1) = [0] x1 + [0] proper^#(x1) = [0] x1 + [0] c_12() = [0] c_13(x1) = [0] x1 + [0] c_14() = [0] c_15(x1) = [0] x1 + [0] c_16() = [0] c_17(x1) = [0] x1 + [0] c_18() = [0] c_19(x1) = [0] x1 + [0] c_20(x1) = [0] x1 + [0] c_21(x1) = [0] x1 + [0] c_22(x1) = [0] x1 + [0] c_23(x1) = [0] x1 + [0] top^#(x1) = [0] x1 + [0] c_24(x1) = [0] x1 + [0] c_25(x1) = [0] x1 + [0] We have applied the subprocessor on the resulting DP-problem: 'Weight Gap Principle' ---------------------- Answer: YES(?,O(n^1)) Input Problem: innermost DP runtime-complexity with respect to Strict Rules: {active^#(and(tt(), X)) -> c_1()} Weak Rules: {} Details: We apply the weight gap principle, strictly orienting the rules {active^#(and(tt(), X)) -> c_1()} and weakly orienting the rules {} using the following strongly linear interpretation: Processor 'Matrix Interpretation' oriented the following rules strictly: {active^#(and(tt(), X)) -> c_1()} Details: Interpretation Functions: active(x1) = [0] x1 + [0] zeros() = [0] mark(x1) = [0] x1 + [0] cons(x1, x2) = [0] x1 + [0] x2 + [0] 0() = [0] and(x1, x2) = [1] x1 + [1] x2 + [0] tt() = [0] length(x1) = [0] x1 + [0] nil() = [0] s(x1) = [0] x1 + [0] proper(x1) = [0] x1 + [0] ok(x1) = [0] x1 + [0] top(x1) = [0] x1 + [0] active^#(x1) = [1] x1 + [1] c_0(x1) = [0] x1 + [0] cons^#(x1, x2) = [0] x1 + [0] x2 + [0] c_1() = [0] c_2() = [0] c_3(x1) = [0] x1 + [0] s^#(x1) = [0] x1 + [0] c_4(x1) = [0] x1 + [0] c_5(x1) = [0] x1 + [0] and^#(x1, x2) = [0] x1 + [0] x2 + [0] c_6(x1) = [0] x1 + [0] length^#(x1) = [0] x1 + [0] c_7(x1) = [0] x1 + [0] c_8(x1) = [0] x1 + [0] c_9(x1) = [0] x1 + [0] c_10(x1) = [0] x1 + [0] c_11(x1) = [0] x1 + [0] proper^#(x1) = [0] x1 + [0] c_12() = [0] c_13(x1) = [0] x1 + [0] c_14() = [0] c_15(x1) = [0] x1 + [0] c_16() = [0] c_17(x1) = [0] x1 + [0] c_18() = [0] c_19(x1) = [0] x1 + [0] c_20(x1) = [0] x1 + [0] c_21(x1) = [0] x1 + [0] c_22(x1) = [0] x1 + [0] c_23(x1) = [0] x1 + [0] top^#(x1) = [0] x1 + [0] c_24(x1) = [0] x1 + [0] c_25(x1) = [0] x1 + [0] Finally we apply the subprocessor 'Empty TRS' ----------- Answer: YES(?,O(1)) Input Problem: innermost DP runtime-complexity with respect to Strict Rules: {} Weak Rules: {active^#(and(tt(), X)) -> c_1()} Details: The given problem does not contain any strict rules 23) {proper^#(0()) -> c_14()} The usable rules for this path are empty. We have oriented the usable rules with the following strongly linear interpretation: Interpretation Functions: active(x1) = [0] x1 + [0] zeros() = [0] mark(x1) = [0] x1 + [0] cons(x1, x2) = [0] x1 + [0] x2 + [0] 0() = [0] and(x1, x2) = [0] x1 + [0] x2 + [0] tt() = [0] length(x1) = [0] x1 + [0] nil() = [0] s(x1) = [0] x1 + [0] proper(x1) = [0] x1 + [0] ok(x1) = [0] x1 + [0] top(x1) = [0] x1 + [0] active^#(x1) = [0] x1 + [0] c_0(x1) = [0] x1 + [0] cons^#(x1, x2) = [0] x1 + [0] x2 + [0] c_1() = [0] c_2() = [0] c_3(x1) = [0] x1 + [0] s^#(x1) = [0] x1 + [0] c_4(x1) = [0] x1 + [0] c_5(x1) = [0] x1 + [0] and^#(x1, x2) = [0] x1 + [0] x2 + [0] c_6(x1) = [0] x1 + [0] length^#(x1) = [0] x1 + [0] c_7(x1) = [0] x1 + [0] c_8(x1) = [0] x1 + [0] c_9(x1) = [0] x1 + [0] c_10(x1) = [0] x1 + [0] c_11(x1) = [0] x1 + [0] proper^#(x1) = [0] x1 + [0] c_12() = [0] c_13(x1) = [0] x1 + [0] c_14() = [0] c_15(x1) = [0] x1 + [0] c_16() = [0] c_17(x1) = [0] x1 + [0] c_18() = [0] c_19(x1) = [0] x1 + [0] c_20(x1) = [0] x1 + [0] c_21(x1) = [0] x1 + [0] c_22(x1) = [0] x1 + [0] c_23(x1) = [0] x1 + [0] top^#(x1) = [0] x1 + [0] c_24(x1) = [0] x1 + [0] c_25(x1) = [0] x1 + [0] We have applied the subprocessor on the resulting DP-problem: 'Weight Gap Principle' ---------------------- Answer: YES(?,O(n^1)) Input Problem: innermost DP runtime-complexity with respect to Strict Rules: {proper^#(0()) -> c_14()} Weak Rules: {} Details: We apply the weight gap principle, strictly orienting the rules {proper^#(0()) -> c_14()} and weakly orienting the rules {} using the following strongly linear interpretation: Processor 'Matrix Interpretation' oriented the following rules strictly: {proper^#(0()) -> c_14()} Details: Interpretation Functions: active(x1) = [0] x1 + [0] zeros() = [0] mark(x1) = [0] x1 + [0] cons(x1, x2) = [0] x1 + [0] x2 + [0] 0() = [0] and(x1, x2) = [0] x1 + [0] x2 + [0] tt() = [0] length(x1) = [0] x1 + [0] nil() = [0] s(x1) = [0] x1 + [0] proper(x1) = [0] x1 + [0] ok(x1) = [0] x1 + [0] top(x1) = [0] x1 + [0] active^#(x1) = [0] x1 + [0] c_0(x1) = [0] x1 + [0] cons^#(x1, x2) = [0] x1 + [0] x2 + [0] c_1() = [0] c_2() = [0] c_3(x1) = [0] x1 + [0] s^#(x1) = [0] x1 + [0] c_4(x1) = [0] x1 + [0] c_5(x1) = [0] x1 + [0] and^#(x1, x2) = [0] x1 + [0] x2 + [0] c_6(x1) = [0] x1 + [0] length^#(x1) = [0] x1 + [0] c_7(x1) = [0] x1 + [0] c_8(x1) = [0] x1 + [0] c_9(x1) = [0] x1 + [0] c_10(x1) = [0] x1 + [0] c_11(x1) = [0] x1 + [0] proper^#(x1) = [1] x1 + [1] c_12() = [0] c_13(x1) = [0] x1 + [0] c_14() = [0] c_15(x1) = [0] x1 + [0] c_16() = [0] c_17(x1) = [0] x1 + [0] c_18() = [0] c_19(x1) = [0] x1 + [0] c_20(x1) = [0] x1 + [0] c_21(x1) = [0] x1 + [0] c_22(x1) = [0] x1 + [0] c_23(x1) = [0] x1 + [0] top^#(x1) = [0] x1 + [0] c_24(x1) = [0] x1 + [0] c_25(x1) = [0] x1 + [0] Finally we apply the subprocessor 'Empty TRS' ----------- Answer: YES(?,O(1)) Input Problem: innermost DP runtime-complexity with respect to Strict Rules: {} Weak Rules: {proper^#(0()) -> c_14()} Details: The given problem does not contain any strict rules 24) {proper^#(zeros()) -> c_12()} The usable rules for this path are empty. We have oriented the usable rules with the following strongly linear interpretation: Interpretation Functions: active(x1) = [0] x1 + [0] zeros() = [0] mark(x1) = [0] x1 + [0] cons(x1, x2) = [0] x1 + [0] x2 + [0] 0() = [0] and(x1, x2) = [0] x1 + [0] x2 + [0] tt() = [0] length(x1) = [0] x1 + [0] nil() = [0] s(x1) = [0] x1 + [0] proper(x1) = [0] x1 + [0] ok(x1) = [0] x1 + [0] top(x1) = [0] x1 + [0] active^#(x1) = [0] x1 + [0] c_0(x1) = [0] x1 + [0] cons^#(x1, x2) = [0] x1 + [0] x2 + [0] c_1() = [0] c_2() = [0] c_3(x1) = [0] x1 + [0] s^#(x1) = [0] x1 + [0] c_4(x1) = [0] x1 + [0] c_5(x1) = [0] x1 + [0] and^#(x1, x2) = [0] x1 + [0] x2 + [0] c_6(x1) = [0] x1 + [0] length^#(x1) = [0] x1 + [0] c_7(x1) = [0] x1 + [0] c_8(x1) = [0] x1 + [0] c_9(x1) = [0] x1 + [0] c_10(x1) = [0] x1 + [0] c_11(x1) = [0] x1 + [0] proper^#(x1) = [0] x1 + [0] c_12() = [0] c_13(x1) = [0] x1 + [0] c_14() = [0] c_15(x1) = [0] x1 + [0] c_16() = [0] c_17(x1) = [0] x1 + [0] c_18() = [0] c_19(x1) = [0] x1 + [0] c_20(x1) = [0] x1 + [0] c_21(x1) = [0] x1 + [0] c_22(x1) = [0] x1 + [0] c_23(x1) = [0] x1 + [0] top^#(x1) = [0] x1 + [0] c_24(x1) = [0] x1 + [0] c_25(x1) = [0] x1 + [0] We have applied the subprocessor on the resulting DP-problem: 'Weight Gap Principle' ---------------------- Answer: YES(?,O(n^1)) Input Problem: innermost DP runtime-complexity with respect to Strict Rules: {proper^#(zeros()) -> c_12()} Weak Rules: {} Details: We apply the weight gap principle, strictly orienting the rules {proper^#(zeros()) -> c_12()} and weakly orienting the rules {} using the following strongly linear interpretation: Processor 'Matrix Interpretation' oriented the following rules strictly: {proper^#(zeros()) -> c_12()} Details: Interpretation Functions: active(x1) = [0] x1 + [0] zeros() = [0] mark(x1) = [0] x1 + [0] cons(x1, x2) = [0] x1 + [0] x2 + [0] 0() = [0] and(x1, x2) = [0] x1 + [0] x2 + [0] tt() = [0] length(x1) = [0] x1 + [0] nil() = [0] s(x1) = [0] x1 + [0] proper(x1) = [0] x1 + [0] ok(x1) = [0] x1 + [0] top(x1) = [0] x1 + [0] active^#(x1) = [0] x1 + [0] c_0(x1) = [0] x1 + [0] cons^#(x1, x2) = [0] x1 + [0] x2 + [0] c_1() = [0] c_2() = [0] c_3(x1) = [0] x1 + [0] s^#(x1) = [0] x1 + [0] c_4(x1) = [0] x1 + [0] c_5(x1) = [0] x1 + [0] and^#(x1, x2) = [0] x1 + [0] x2 + [0] c_6(x1) = [0] x1 + [0] length^#(x1) = [0] x1 + [0] c_7(x1) = [0] x1 + [0] c_8(x1) = [0] x1 + [0] c_9(x1) = [0] x1 + [0] c_10(x1) = [0] x1 + [0] c_11(x1) = [0] x1 + [0] proper^#(x1) = [1] x1 + [1] c_12() = [0] c_13(x1) = [0] x1 + [0] c_14() = [0] c_15(x1) = [0] x1 + [0] c_16() = [0] c_17(x1) = [0] x1 + [0] c_18() = [0] c_19(x1) = [0] x1 + [0] c_20(x1) = [0] x1 + [0] c_21(x1) = [0] x1 + [0] c_22(x1) = [0] x1 + [0] c_23(x1) = [0] x1 + [0] top^#(x1) = [0] x1 + [0] c_24(x1) = [0] x1 + [0] c_25(x1) = [0] x1 + [0] Finally we apply the subprocessor 'Empty TRS' ----------- Answer: YES(?,O(1)) Input Problem: innermost DP runtime-complexity with respect to Strict Rules: {} Weak Rules: {proper^#(zeros()) -> c_12()} Details: The given problem does not contain any strict rules 25) {proper^#(nil()) -> c_18()} The usable rules for this path are empty. We have oriented the usable rules with the following strongly linear interpretation: Interpretation Functions: active(x1) = [0] x1 + [0] zeros() = [0] mark(x1) = [0] x1 + [0] cons(x1, x2) = [0] x1 + [0] x2 + [0] 0() = [0] and(x1, x2) = [0] x1 + [0] x2 + [0] tt() = [0] length(x1) = [0] x1 + [0] nil() = [0] s(x1) = [0] x1 + [0] proper(x1) = [0] x1 + [0] ok(x1) = [0] x1 + [0] top(x1) = [0] x1 + [0] active^#(x1) = [0] x1 + [0] c_0(x1) = [0] x1 + [0] cons^#(x1, x2) = [0] x1 + [0] x2 + [0] c_1() = [0] c_2() = [0] c_3(x1) = [0] x1 + [0] s^#(x1) = [0] x1 + [0] c_4(x1) = [0] x1 + [0] c_5(x1) = [0] x1 + [0] and^#(x1, x2) = [0] x1 + [0] x2 + [0] c_6(x1) = [0] x1 + [0] length^#(x1) = [0] x1 + [0] c_7(x1) = [0] x1 + [0] c_8(x1) = [0] x1 + [0] c_9(x1) = [0] x1 + [0] c_10(x1) = [0] x1 + [0] c_11(x1) = [0] x1 + [0] proper^#(x1) = [0] x1 + [0] c_12() = [0] c_13(x1) = [0] x1 + [0] c_14() = [0] c_15(x1) = [0] x1 + [0] c_16() = [0] c_17(x1) = [0] x1 + [0] c_18() = [0] c_19(x1) = [0] x1 + [0] c_20(x1) = [0] x1 + [0] c_21(x1) = [0] x1 + [0] c_22(x1) = [0] x1 + [0] c_23(x1) = [0] x1 + [0] top^#(x1) = [0] x1 + [0] c_24(x1) = [0] x1 + [0] c_25(x1) = [0] x1 + [0] We have applied the subprocessor on the resulting DP-problem: 'Weight Gap Principle' ---------------------- Answer: YES(?,O(n^1)) Input Problem: innermost DP runtime-complexity with respect to Strict Rules: {proper^#(nil()) -> c_18()} Weak Rules: {} Details: We apply the weight gap principle, strictly orienting the rules {proper^#(nil()) -> c_18()} and weakly orienting the rules {} using the following strongly linear interpretation: Processor 'Matrix Interpretation' oriented the following rules strictly: {proper^#(nil()) -> c_18()} Details: Interpretation Functions: active(x1) = [0] x1 + [0] zeros() = [0] mark(x1) = [0] x1 + [0] cons(x1, x2) = [0] x1 + [0] x2 + [0] 0() = [0] and(x1, x2) = [0] x1 + [0] x2 + [0] tt() = [0] length(x1) = [0] x1 + [0] nil() = [0] s(x1) = [0] x1 + [0] proper(x1) = [0] x1 + [0] ok(x1) = [0] x1 + [0] top(x1) = [0] x1 + [0] active^#(x1) = [0] x1 + [0] c_0(x1) = [0] x1 + [0] cons^#(x1, x2) = [0] x1 + [0] x2 + [0] c_1() = [0] c_2() = [0] c_3(x1) = [0] x1 + [0] s^#(x1) = [0] x1 + [0] c_4(x1) = [0] x1 + [0] c_5(x1) = [0] x1 + [0] and^#(x1, x2) = [0] x1 + [0] x2 + [0] c_6(x1) = [0] x1 + [0] length^#(x1) = [0] x1 + [0] c_7(x1) = [0] x1 + [0] c_8(x1) = [0] x1 + [0] c_9(x1) = [0] x1 + [0] c_10(x1) = [0] x1 + [0] c_11(x1) = [0] x1 + [0] proper^#(x1) = [1] x1 + [1] c_12() = [0] c_13(x1) = [0] x1 + [0] c_14() = [0] c_15(x1) = [0] x1 + [0] c_16() = [0] c_17(x1) = [0] x1 + [0] c_18() = [0] c_19(x1) = [0] x1 + [0] c_20(x1) = [0] x1 + [0] c_21(x1) = [0] x1 + [0] c_22(x1) = [0] x1 + [0] c_23(x1) = [0] x1 + [0] top^#(x1) = [0] x1 + [0] c_24(x1) = [0] x1 + [0] c_25(x1) = [0] x1 + [0] Finally we apply the subprocessor 'Empty TRS' ----------- Answer: YES(?,O(1)) Input Problem: innermost DP runtime-complexity with respect to Strict Rules: {} Weak Rules: {proper^#(nil()) -> c_18()} Details: The given problem does not contain any strict rules 26) {proper^#(tt()) -> c_16()} The usable rules for this path are empty. We have oriented the usable rules with the following strongly linear interpretation: Interpretation Functions: active(x1) = [0] x1 + [0] zeros() = [0] mark(x1) = [0] x1 + [0] cons(x1, x2) = [0] x1 + [0] x2 + [0] 0() = [0] and(x1, x2) = [0] x1 + [0] x2 + [0] tt() = [0] length(x1) = [0] x1 + [0] nil() = [0] s(x1) = [0] x1 + [0] proper(x1) = [0] x1 + [0] ok(x1) = [0] x1 + [0] top(x1) = [0] x1 + [0] active^#(x1) = [0] x1 + [0] c_0(x1) = [0] x1 + [0] cons^#(x1, x2) = [0] x1 + [0] x2 + [0] c_1() = [0] c_2() = [0] c_3(x1) = [0] x1 + [0] s^#(x1) = [0] x1 + [0] c_4(x1) = [0] x1 + [0] c_5(x1) = [0] x1 + [0] and^#(x1, x2) = [0] x1 + [0] x2 + [0] c_6(x1) = [0] x1 + [0] length^#(x1) = [0] x1 + [0] c_7(x1) = [0] x1 + [0] c_8(x1) = [0] x1 + [0] c_9(x1) = [0] x1 + [0] c_10(x1) = [0] x1 + [0] c_11(x1) = [0] x1 + [0] proper^#(x1) = [0] x1 + [0] c_12() = [0] c_13(x1) = [0] x1 + [0] c_14() = [0] c_15(x1) = [0] x1 + [0] c_16() = [0] c_17(x1) = [0] x1 + [0] c_18() = [0] c_19(x1) = [0] x1 + [0] c_20(x1) = [0] x1 + [0] c_21(x1) = [0] x1 + [0] c_22(x1) = [0] x1 + [0] c_23(x1) = [0] x1 + [0] top^#(x1) = [0] x1 + [0] c_24(x1) = [0] x1 + [0] c_25(x1) = [0] x1 + [0] We have applied the subprocessor on the resulting DP-problem: 'Weight Gap Principle' ---------------------- Answer: YES(?,O(n^1)) Input Problem: innermost DP runtime-complexity with respect to Strict Rules: {proper^#(tt()) -> c_16()} Weak Rules: {} Details: We apply the weight gap principle, strictly orienting the rules {proper^#(tt()) -> c_16()} and weakly orienting the rules {} using the following strongly linear interpretation: Processor 'Matrix Interpretation' oriented the following rules strictly: {proper^#(tt()) -> c_16()} Details: Interpretation Functions: active(x1) = [0] x1 + [0] zeros() = [0] mark(x1) = [0] x1 + [0] cons(x1, x2) = [0] x1 + [0] x2 + [0] 0() = [0] and(x1, x2) = [0] x1 + [0] x2 + [0] tt() = [0] length(x1) = [0] x1 + [0] nil() = [0] s(x1) = [0] x1 + [0] proper(x1) = [0] x1 + [0] ok(x1) = [0] x1 + [0] top(x1) = [0] x1 + [0] active^#(x1) = [0] x1 + [0] c_0(x1) = [0] x1 + [0] cons^#(x1, x2) = [0] x1 + [0] x2 + [0] c_1() = [0] c_2() = [0] c_3(x1) = [0] x1 + [0] s^#(x1) = [0] x1 + [0] c_4(x1) = [0] x1 + [0] c_5(x1) = [0] x1 + [0] and^#(x1, x2) = [0] x1 + [0] x2 + [0] c_6(x1) = [0] x1 + [0] length^#(x1) = [0] x1 + [0] c_7(x1) = [0] x1 + [0] c_8(x1) = [0] x1 + [0] c_9(x1) = [0] x1 + [0] c_10(x1) = [0] x1 + [0] c_11(x1) = [0] x1 + [0] proper^#(x1) = [1] x1 + [1] c_12() = [0] c_13(x1) = [0] x1 + [0] c_14() = [0] c_15(x1) = [0] x1 + [0] c_16() = [0] c_17(x1) = [0] x1 + [0] c_18() = [0] c_19(x1) = [0] x1 + [0] c_20(x1) = [0] x1 + [0] c_21(x1) = [0] x1 + [0] c_22(x1) = [0] x1 + [0] c_23(x1) = [0] x1 + [0] top^#(x1) = [0] x1 + [0] c_24(x1) = [0] x1 + [0] c_25(x1) = [0] x1 + [0] Finally we apply the subprocessor 'Empty TRS' ----------- Answer: YES(?,O(1)) Input Problem: innermost DP runtime-complexity with respect to Strict Rules: {} Weak Rules: {proper^#(tt()) -> c_16()} Details: The given problem does not contain any strict rules